public void eventReceived(Action action, Event resource) {
                    Exchange exchange = createExchange(false);
                    exchange.getIn().setBody(resource);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_ACTION, action);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_TIMESTAMP, System.currentTimeMillis());
                    try {
                        processor.process(exchange);
                    } catch (Exception e) {
                        getExceptionHandler().handleException("Error during processing", exchange, e);
                    } finally {
                        releaseExchange(exchange, false);
                    }
                }

    public InputGuardrailResult validate(UserMessage userMessage) {
        if (userMessage == null || userMessage.singleText() == null) {
            return success();
        }

        String text = userMessage.singleText();
        List<InjectionType> detected = new ArrayList<>();

        for (InjectionPattern pattern : patterns) {
            if (!detectTypes.contains(pattern.getType())) {
                continue;
            }

            if (pattern.getPattern().matcher(text).find()) {
                detected.add(pattern.getType());

                if (strict) {
                    return failure(String.format(
                            "Potential code injection detected: %s. " +
                                                 "Please remove any code or command patterns from your message.",
                            pattern.getType()));
                }
            }
        }

         
        if (!strict && detected.size() >= 2) {
            return failure(String.format(
                    "Multiple potential code injection patterns detected: %s. " +
                                         "Please rephrase your message without code-like syntax.",
                    detected));
        }

        return success();
    }

    public static DataFormatModel generateDataFormatModel(JsonObject obj) {
        JsonObject mobj = (JsonObject) obj.get("dataformat");
        DataFormatModel model = new DataFormatModel();
        parseModel(mobj, model);
        parseArtifact(mobj, model);
        model.setModelName(mobj.getString("modelName"));
        model.setModelJavaType(mobj.getString("modelJavaType"));
        JsonObject mprp = (JsonObject) obj.get("properties");
        for (Map.Entry<String, Object> entry : mprp.entrySet()) {
            JsonObject mp = (JsonObject) entry.getValue();
            DataFormatOptionModel option = new DataFormatOptionModel();
            parseOption(mp, option, entry.getKey());
            model.addOption(option);
        }
        return model;
    }

    public static AS2DispositionType parseDispositionType(String dispositionTypeString) {
        switch (dispositionTypeString) {
            case "processed":
                return PROCESSED;
            case "failed":
                return FAILED;
            default:
                return null;
        }
    }

    protected String createEndpointUri() {
        if (channelKey != null) {
            return "flowable:" + channelKey;
        } else if (camelInboundChannel != null) {
            return "flowable:" + camelInboundChannel.getKey();
        } else {
            return "flowable:" + camelOutboundChannel.getKey();
        }
    }

    protected RouteConfigurationDefinition createRouteConfiguration(String id) {
        RouteConfigurationDefinition config = new RouteConfigurationDefinition();
        if (id != null) {
            config.setId(id);
        }
        if (resource != null) {
            config.setResource(resource);
        }
        CamelContextAware.trySetCamelContext(config, camelContext);
        return config;
    }

    protected void doStart() throws Exception {
        if (curator == null) {
             
            ObjectHelper.notNull(getCamelContext(), "Camel Context");
            ObjectHelper.notNull(configuration.getBasePath(), "ZooKeeper base path");

            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("Starting ZooKeeper Curator with namespace '{}', nodes: '{}'",
                        configuration.getNamespace(),
                        String.join(",", configuration.getNodes()));
            }

            curator = ZooKeeperCuratorHelper.createCurator(configuration);
            curator.start();
        }

        if (serviceDiscovery == null) {
             
            ObjectHelper.notNull(configuration.getBasePath(), "ZooKeeper base path");

            LOGGER.debug("Starting ZooKeeper ServiceDiscoveryBuilder with base path '{}'",
                    configuration.getBasePath());

            serviceDiscovery = ZooKeeperCuratorHelper.createServiceDiscovery(configuration, curator, MetaData.class);
            serviceDiscovery.start();
        }
    }

    protected static String getPath(String uri) {
         
        String path = null;
        int index = uri.indexOf(':');
        if (index != -1) {
            index = uri.indexOf(':', index + 1);
            if (index != -1) {
                path = uri.substring(index + 1);
                index = path.indexOf('?');
                if (index != -1) {
                    path = path.substring(0, index);
                }
                path = path.replace(":", "");
                path = URLDecoder.decode(path, StandardCharsets.UTF_8);
            }
        }
        return path;
    }

    protected void getValues(Message message) throws Exception {
        Object result;

        boolean asString = message.getHeader(ConsulConstants.CONSUL_VALUE_AS_STRING, getConfiguration().isValueAsString(),
                Boolean.class);
        if (asString) {
            result = getClient().getValuesAsString(
                    getMandatoryHeader(message, ConsulConstants.CONSUL_KEY, getConfiguration().getKey(), String.class));
        } else {
            result = getClient().getValues(
                    getMandatoryHeader(message, ConsulConstants.CONSUL_KEY, getConfiguration().getKey(), String.class),
                    message.getHeader(ConsulConstants.CONSUL_OPTIONS, QueryOptions.BLANK, QueryOptions.class));
        }

        setBodyAndResult(message, result);
    }

    private String codeWithLineNumbers() {
        StringBuilder sb = new StringBuilder(256);
        String[] lines = code.split("\n");
        int counter = 0;
        for (String line : lines) {
            String s = String.format("%3d %s", ++counter, line);
            sb.append(s);
            sb.append("\n");
        }
        return sb.toString();
    }

    public Exchange receiveNoWait(Endpoint endpoint) {
        if (camelContext.isStopped()) {
            throw new RejectedExecutionException(CONTEXT_IS_STOPPED);
        }

        LOG.debug("<<<< {}", endpoint);
        PollingConsumer consumer = null;
        try {
            consumer = acquirePollingConsumer(endpoint);
            return consumer.receiveNoWait();
        } finally {
            if (consumer != null) {
                releasePollingConsumer(endpoint, consumer);
            }
        }
    }

    public static String getPrimitiveType(String name) {
         
        if ("java.lang.byte[]".equals(name) || "byte[]".equals(name)) {
            return "string";
        } else if ("java.lang.Byte[]".equals(name) || "Byte[]".equals(name)) {
            return "array";
        } else if ("java.lang.Object[]".equals(name) || "Object[]".equals(name)) {
            return "array";
        } else if ("java.lang.String[]".equals(name) || "String[]".equals(name)) {
            return "array";
        } else if ("java.lang.Character".equals(name) || "Character".equals(name) || "char".equals(name)) {
            return "string";
        } else if ("java.lang.String".equals(name) || "String".equals(name)) {
            return "string";
        } else if ("java.lang.Boolean".equals(name) || "Boolean".equals(name) || "boolean".equals(name)) {
            return "boolean";
        } else if ("java.lang.Integer".equals(name) || "Integer".equals(name) || "int".equals(name)) {
            return "integer";
        } else if ("java.lang.Long".equals(name) || "Long".equals(name) || "long".equals(name)) {
            return "integer";
        } else if ("java.lang.Short".equals(name) || "Short".equals(name) || "short".equals(name)) {
            return "integer";
        } else if ("java.lang.Byte".equals(name) || "Byte".equals(name) || "byte".equals(name)) {
            return "integer";
        } else if ("java.lang.Float".equals(name) || "Float".equals(name) || "float".equals(name)) {
            return "number";
        } else if ("java.lang.Double".equals(name) || "Double".equals(name) || "double".equals(name)) {
            return "number";
        }

        return null;
    }

    public static String resolveCamelVersionFromSpringBoot(String repos, String camelSpringBootVersion, boolean download)
            throws Exception {
        DependencyDownloaderClassLoader cl = new DependencyDownloaderClassLoader(CatalogLoader.class.getClassLoader());
        MavenDependencyDownloader downloader = new MavenDependencyDownloader();
        downloader.setRepositories(repos);
        downloader.setClassLoader(cl);
        downloader.setDownload(download);
        try {
            downloader.start();

            List<MavenArtifact> artifacts
                    = downloader.downloadArtifacts("org.apache.camel.springboot", "camel-catalog-provider-springboot",
                            camelSpringBootVersion, true);
            for (MavenArtifact ma : artifacts) {
                String g = ma.getGav().getGroupId();
                String a = ma.getGav().getArtifactId();
                if ("org.apache.camel".equals(g) && "camel-catalog".equals(a)) {
                    return ma.getGav().getVersion();
                }
            }
        } finally {
            downloader.stop();
            downloader.close();
        }

        return null;
    }

    protected Processor createBodyAndHeaderProcessor(final Object body, final String header, final Object headerValue) {
        return new Processor() {
            public void process(Exchange exchange) {
                Message in = exchange.getIn();
                in.setHeader(header, headerValue);
                in.setBody(body);
            }
        };
    }

    public static Predicate isEqualTo(final Expression left, final Expression right) {
        return new BinaryPredicateSupport(left, right) {

            protected boolean matches(Exchange exchange, Object leftValue, Object rightValue) {
                if (leftValue == null && rightValue == null) {
                     
                    return true;
                } else if (leftValue == null || rightValue == null) {
                     
                    return false;
                }

                return ObjectHelper.typeCoerceEquals(exchange.getContext().getTypeConverter(), leftValue, rightValue);
            }

            protected String getOperationText() {
                return "==";
            }
        };
    }

    private Port messageToPort(Message message) {
        Port port = message.getBody(Port.class);

        if (port == null) {
            Map headers = message.getHeaders();
            PortBuilder builder = Builders.port();

            StringHelper.notEmpty(message.getHeader(OpenstackConstants.NAME, String.class), "Name");
            builder.name(message.getHeader(OpenstackConstants.NAME, String.class));

            if (headers.containsKey(NeutronConstants.TENANT_ID)) {
                builder.tenantId(message.getHeader(NeutronConstants.TENANT_ID, String.class));
            }

            if (headers.containsKey(NeutronConstants.NETWORK_ID)) {
                builder.networkId(message.getHeader(NeutronConstants.NETWORK_ID, String.class));
            }

            if (headers.containsKey(NeutronConstants.DEVICE_ID)) {
                builder.deviceId(message.getHeader(NeutronConstants.DEVICE_ID, String.class));
            }

            if (headers.containsKey(NeutronConstants.MAC_ADDRESS)) {
                builder.macAddress(message.getHeader(NeutronConstants.MAC_ADDRESS, String.class));
            }

            port = builder.build();
        }
        return port;
    }

    private void processCreateJob(Exchange exchange, AsyncCallback callback)
            throws InvalidPayloadException {
        Job job = exchange.getIn().getMandatoryBody(Job.class);
        bulkClient.createJob(job, determineHeaders(exchange),
                new JobResponseCallback() {
                    @Override
                    public void onResponse(Job job, Map<String, String> headers, SalesforceException ex) {
                        processResponse(exchange, job, headers, ex, callback);
                    }
                });
    }

    public Object unmarshal(final Exchange exchange, final InputStream stream) throws Exception {
        if (usingIterator) {
            TarIterator tarIterator = new TarIterator(exchange, stream);
            tarIterator.setAllowEmptyDirectory(allowEmptyDirectory);
            return tarIterator;
        } else {
            BufferedInputStream bis = new BufferedInputStream(stream);
            TarArchiveInputStream tis = (TarArchiveInputStream) new ArchiveStreamFactory()
                    .createArchiveInputStream(ArchiveStreamFactory.TAR, bis);
            OutputStreamBuilder osb = OutputStreamBuilder.withExchange(exchange);

            try {
                TarArchiveEntry entry = tis.getNextEntry();
                if (entry != null) {
                    exchange.getMessage().setHeader(FILE_NAME, entry.getName());
                    IOHelper.copy(tis, osb, IOHelper.DEFAULT_BUFFER_SIZE, false, maxDecompressedSize);
                } else {
                    throw new IllegalStateException("Unable to untar the file, it may be corrupted.");
                }

                entry = tis.getNextEntry();
                if (entry != null) {
                    throw new IllegalStateException("Tar file has more than 1 entry.");
                }

                return osb.build();

            } finally {
                IOHelper.close(osb, tis, bis);
            }
        }
    }

    public Map<String, Object> toMap() {
        JsonObject jo = new JsonObject();
        jo.put("camelVersion", version);
        jo.put("runtime", runtime);
        if (runtimeVersion != null) {
            jo.put("runtimeVersion", runtimeVersion);
        }
        if (description != null) {
            jo.put("description", description);
        }
        return jo;
    }

    public Producer createProducer() throws Exception {
        validate();
        JpaProducer producer = new JpaProducer(this, getProducerExpression());
        producer.setQuery(getQuery());
        producer.setNamedQuery(getNamedQuery());
        producer.setNativeQuery(getNativeQuery());
        producer.setParameters(getParameters());
        producer.setResultClass(getResultClass());
        producer.setFindEntity(isFindEntity());
        producer.setUseExecuteUpdate(getUseExecuteUpdate());
        return producer;
    }

    private static String pathAsKey(String path) {
         
        if (path == null || path.equals("/")) {
            path = "";
        }

         
        path = StringHelper.before(path, "?", path);

         
        if (path.endsWith("/")) {
            path = path.substring(0, path.length() - 1);
        }

        return UnsafeUriCharactersEncoder.encodeHttpURI(path);
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.apache.activemq.command.ActiveMQMessage.class, org.apache.camel.Exchange.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toMessage((org.apache.camel.Exchange) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.Processor.class, jakarta.jms.MessageListener.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toProcessor((jakarta.jms.MessageListener) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private List<JsonObject> enrichSourceCode(String routeId, String location, int lines) {
        Route route = getCamelContext().getRoute(routeId);
        if (route == null) {
            return null;
        }
        Resource resource = route.getSourceResource();
        if (resource == null) {
            return null;
        }

        List<JsonObject> code = new ArrayList<>();

        location = StringHelper.afterLast(location, ":");
        int line = 0;
        try {
            if (location != null) {
                line = Integer.parseInt(location);
            }
            LineNumberReader reader = new LineNumberReader(resource.getReader());
            for (int i = 1; i <= line + lines; i++) {
                String t = reader.readLine();
                if (t != null) {
                    int low = line - lines + 2;  
                    int high = line + lines + 1 + 2;
                    if (i >= low && i <= high) {
                        JsonObject c = new JsonObject();
                        c.put("line", i);
                        if (line == i) {
                            c.put("match", true);
                        }
                        c.put("code", Jsoner.escape(t));
                        code.add(c);
                    }
                }
            }
            IOHelper.close(reader);
        } catch (Exception e) {
             
        }

        return code;
    }

        public AnnotationBuilder withIsSecret(JsonNode node) {
            if (node == null) {
                return this;
            }
            if (node.isMissingNode()) {
                return this;
            }
            if (!node.isTextual()) {
                return this;
            }

            return withIsSecret(node.asBoolean());
        }

    public void createBatchQuery(
            String jobId, String soqlQuery, ContentType jobContentType, Map<String, List<String>> headers,
            final BatchInfoResponseCallback callback) {
        final Request post = getRequest(HttpMethod.POST, batchUrl(jobId, null), headers);
        final byte[] queryBytes;
        try {
            queryBytes = soqlQuery.getBytes(StandardCharsets.UTF_8.name());
        } catch (UnsupportedEncodingException e) {
            callback.onResponse(null, Collections.emptyMap(),
                    new SalesforceException("Unexpected exception: " + e.getMessage(), e));
            return;
        }
        post.body(new BytesRequestContent(queryBytes));
        post.headers(mutable -> mutable.add(
                new HttpField(
                        HttpHeader.CONTENT_TYPE,
                        getContentType(jobContentType) + ";charset=" + StandardCharsets.UTF_8.name())));

         
        doHttpRequest(post, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                BatchInfo value = null;
                try {
                    value = unmarshalResponse(response, post, BatchInfo.class);
                } catch (SalesforceException e) {
                    ex = e;
                }
                callback.onResponse(value, headers, ex);
            }
        });
    }

        protected boolean setPropertyOnComponent(
                Component component,
                String name,
                Object value) {
            switch (name) {
            case "additionalProperties": getOrCreateConfiguration((DebeziumPostgresComponent) component).setAdditionalProperties((java.util.Map) value); return true;
            case "bridgeErrorHandler": ((DebeziumPostgresComponent) component).setBridgeErrorHandler((boolean) value); return true;
            case "configuration": ((DebeziumPostgresComponent) component).setConfiguration((org.apache.camel.component.debezium.postgres.configuration.PostgresConnectorEmbeddedDebeziumConfiguration) value); return true;
            case "internalKeyConverter": getOrCreateConfiguration((DebeziumPostgresComponent) component).setInternalKeyConverter((java.lang.String) value); return true;
            case "internalValueConverter": getOrCreateConfiguration((DebeziumPostgresComponent) component).setInternalValueConverter((java.lang.String) value); return true;
            case "offsetCommitPolicy": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOffsetCommitPolicy((java.lang.String) value); return true;
            case "offsetCommitTimeoutMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOffsetCommitTimeoutMs((long) value); return true;
            case "offsetFlushIntervalMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOffsetFlushIntervalMs((long) value); return true;
            case "offsetStorage": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOffsetStorage((java.lang.String) value); return true;
            case "offsetStorageFileName": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOffsetStorageFileName((java.lang.String) value); return true;
            case "offsetStoragePartitions": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOffsetStoragePartitions((int) value); return true;
            case "offsetStorageReplicationFactor": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOffsetStorageReplicationFactor((int) value); return true;
            case "offsetStorageTopic": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOffsetStorageTopic((java.lang.String) value); return true;
            case "autowiredEnabled": ((DebeziumPostgresComponent) component).setAutowiredEnabled((boolean) value); return true;
            case "binaryHandlingMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setBinaryHandlingMode((java.lang.String) value); return true;
            case "columnExcludeList": getOrCreateConfiguration((DebeziumPostgresComponent) component).setColumnExcludeList((java.lang.String) value); return true;
            case "columnIncludeList": getOrCreateConfiguration((DebeziumPostgresComponent) component).setColumnIncludeList((java.lang.String) value); return true;
            case "columnPropagateSourceType": getOrCreateConfiguration((DebeziumPostgresComponent) component).setColumnPropagateSourceType((java.lang.String) value); return true;
            case "connectionValidationTimeoutMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setConnectionValidationTimeoutMs((long) value); return true;
            case "converters": getOrCreateConfiguration((DebeziumPostgresComponent) component).setConverters((java.lang.String) value); return true;
            case "customMetricTags": getOrCreateConfiguration((DebeziumPostgresComponent) component).setCustomMetricTags((java.lang.String) value); return true;
            case "customSanitizePattern": getOrCreateConfiguration((DebeziumPostgresComponent) component).setCustomSanitizePattern((java.lang.String) value); return true;
            case "databaseDbname": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabaseDbname((java.lang.String) value); return true;
            case "databaseHostname": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabaseHostname((java.lang.String) value); return true;
            case "databaseInitialStatements": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabaseInitialStatements((java.lang.String) value); return true;
            case "databasePassword": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabasePassword((java.lang.String) value); return true;
            case "databasePort": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabasePort((int) value); return true;
            case "databaseQueryTimeoutMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabaseQueryTimeoutMs((int) value); return true;
            case "databaseSslcert": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabaseSslcert((java.lang.String) value); return true;
            case "databaseSslfactory": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabaseSslfactory((java.lang.String) value); return true;
            case "databaseSslkey": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabaseSslkey((java.lang.String) value); return true;
            case "databaseSslmode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabaseSslmode((java.lang.String) value); return true;
            case "databaseSslpassword": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabaseSslpassword((java.lang.String) value); return true;
            case "databaseSslrootcert": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabaseSslrootcert((java.lang.String) value); return true;
            case "databaseTcpkeepalive": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabaseTcpkeepalive((boolean) value); return true;
            case "databaseUser": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabaseUser((java.lang.String) value); return true;
            case "datatypePropagateSourceType": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatatypePropagateSourceType((java.lang.String) value); return true;
            case "decimalHandlingMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDecimalHandlingMode((java.lang.String) value); return true;
            case "errorsMaxRetries": getOrCreateConfiguration((DebeziumPostgresComponent) component).setErrorsMaxRetries((int) value); return true;
            case "eventProcessingFailureHandlingMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setEventProcessingFailureHandlingMode((java.lang.String) value); return true;
            case "executorShutdownTimeoutMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setExecutorShutdownTimeoutMs((long) value); return true;
            case "extendedHeadersEnabled": getOrCreateConfiguration((DebeziumPostgresComponent) component).setExtendedHeadersEnabled((boolean) value); return true;
            case "guardrailCollectionsLimitAction": getOrCreateConfiguration((DebeziumPostgresComponent) component).setGuardrailCollectionsLimitAction((java.lang.String) value); return true;
            case "guardrailCollectionsMax": getOrCreateConfiguration((DebeziumPostgresComponent) component).setGuardrailCollectionsMax((int) value); return true;
            case "heartbeatActionQuery": getOrCreateConfiguration((DebeziumPostgresComponent) component).setHeartbeatActionQuery((java.lang.String) value); return true;
            case "heartbeatIntervalMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setHeartbeatIntervalMs((int) value); return true;
            case "heartbeatTopicsPrefix": getOrCreateConfiguration((DebeziumPostgresComponent) component).setHeartbeatTopicsPrefix((java.lang.String) value); return true;
            case "hstoreHandlingMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setHstoreHandlingMode((java.lang.String) value); return true;
            case "includeSchemaComments": getOrCreateConfiguration((DebeziumPostgresComponent) component).setIncludeSchemaComments((boolean) value); return true;
            case "includeUnknownDatatypes": getOrCreateConfiguration((DebeziumPostgresComponent) component).setIncludeUnknownDatatypes((boolean) value); return true;
            case "incrementalSnapshotChunkSize": getOrCreateConfiguration((DebeziumPostgresComponent) component).setIncrementalSnapshotChunkSize((int) value); return true;
            case "incrementalSnapshotWatermarkingStrategy": getOrCreateConfiguration((DebeziumPostgresComponent) component).setIncrementalSnapshotWatermarkingStrategy((java.lang.String) value); return true;
            case "intervalHandlingMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setIntervalHandlingMode((java.lang.String) value); return true;
            case "lsnFlushMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setLsnFlushMode((java.lang.String) value); return true;
            case "lsnFlushTimeoutAction": getOrCreateConfiguration((DebeziumPostgresComponent) component).setLsnFlushTimeoutAction((java.lang.String) value); return true;
            case "lsnFlushTimeoutMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setLsnFlushTimeoutMs((long) value); return true;
            case "maxBatchSize": getOrCreateConfiguration((DebeziumPostgresComponent) component).setMaxBatchSize((int) value); return true;
            case "maxQueueSize": getOrCreateConfiguration((DebeziumPostgresComponent) component).setMaxQueueSize((int) value); return true;
            case "maxQueueSizeInBytes": getOrCreateConfiguration((DebeziumPostgresComponent) component).setMaxQueueSizeInBytes((long) value); return true;
            case "messageKeyColumns": getOrCreateConfiguration((DebeziumPostgresComponent) component).setMessageKeyColumns((java.lang.String) value); return true;
            case "messagePrefixExcludeList": getOrCreateConfiguration((DebeziumPostgresComponent) component).setMessagePrefixExcludeList((java.lang.String) value); return true;
            case "messagePrefixIncludeList": getOrCreateConfiguration((DebeziumPostgresComponent) component).setMessagePrefixIncludeList((java.lang.String) value); return true;
            case "notificationEnabledChannels": getOrCreateConfiguration((DebeziumPostgresComponent) component).setNotificationEnabledChannels((java.lang.String) value); return true;
            case "notificationSinkTopicName": getOrCreateConfiguration((DebeziumPostgresComponent) component).setNotificationSinkTopicName((java.lang.String) value); return true;
            case "openlineageIntegrationConfigFilePath": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOpenlineageIntegrationConfigFilePath((java.lang.String) value); return true;
            case "openlineageIntegrationDatasetKafkaBootstrapServers": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOpenlineageIntegrationDatasetKafkaBootstrapServers((java.lang.String) value); return true;
            case "openlineageIntegrationEnabled": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOpenlineageIntegrationEnabled((boolean) value); return true;
            case "openlineageIntegrationJobDescription": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOpenlineageIntegrationJobDescription((java.lang.String) value); return true;
            case "openlineageIntegrationJobNamespace": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOpenlineageIntegrationJobNamespace((java.lang.String) value); return true;
            case "openlineageIntegrationJobOwners": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOpenlineageIntegrationJobOwners((java.lang.String) value); return true;
            case "openlineageIntegrationJobTags": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOpenlineageIntegrationJobTags((java.lang.String) value); return true;
            case "pluginName": getOrCreateConfiguration((DebeziumPostgresComponent) component).setPluginName((java.lang.String) value); return true;
            case "pollIntervalMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setPollIntervalMs((long) value); return true;
            case "postProcessors": getOrCreateConfiguration((DebeziumPostgresComponent) component).setPostProcessors((java.lang.String) value); return true;
            case "provideTransactionMetadata": getOrCreateConfiguration((DebeziumPostgresComponent) component).setProvideTransactionMetadata((boolean) value); return true;
            case "publicationAutocreateMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setPublicationAutocreateMode((java.lang.String) value); return true;
            case "publicationName": getOrCreateConfiguration((DebeziumPostgresComponent) component).setPublicationName((java.lang.String) value); return true;
            case "publishViaPartitionRoot": getOrCreateConfiguration((DebeziumPostgresComponent) component).setPublishViaPartitionRoot((boolean) value); return true;
            case "queryFetchSize": getOrCreateConfiguration((DebeziumPostgresComponent) component).setQueryFetchSize((int) value); return true;
            case "replicaIdentityAutosetValues": getOrCreateConfiguration((DebeziumPostgresComponent) component).setReplicaIdentityAutosetValues((java.lang.String) value); return true;
            case "retriableRestartConnectorWaitMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setRetriableRestartConnectorWaitMs((long) value); return true;
            case "schemaExcludeList": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSchemaExcludeList((java.lang.String) value); return true;
            case "schemaHistoryInternalFileFilename": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSchemaHistoryInternalFileFilename((java.lang.String) value); return true;
            case "schemaIncludeList": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSchemaIncludeList((java.lang.String) value); return true;
            case "schemaNameAdjustmentMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSchemaNameAdjustmentMode((java.lang.String) value); return true;
            case "schemaRefreshMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSchemaRefreshMode((java.lang.String) value); return true;
            case "signalDataCollection": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSignalDataCollection((java.lang.String) value); return true;
            case "signalEnabledChannels": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSignalEnabledChannels((java.lang.String) value); return true;
            case "signalPollIntervalMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSignalPollIntervalMs((long) value); return true;
            case "skippedOperations": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSkippedOperations((java.lang.String) value); return true;
            case "slotDropOnStop": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSlotDropOnStop((boolean) value); return true;
            case "slotFailover": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSlotFailover((boolean) value); return true;
            case "slotMaxRetries": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSlotMaxRetries((int) value); return true;
            case "slotName": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSlotName((java.lang.String) value); return true;
            case "slotRetryDelayMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSlotRetryDelayMs((long) value); return true;
            case "slotStreamParams": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSlotStreamParams((java.lang.String) value); return true;
            case "snapshotDelayMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotDelayMs((long) value); return true;
            case "snapshotFetchSize": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotFetchSize((int) value); return true;
            case "snapshotIncludeCollectionList": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotIncludeCollectionList((java.lang.String) value); return true;
            case "snapshotIsolationMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotIsolationMode((java.lang.String) value); return true;
            case "snapshotLockingMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotLockingMode((java.lang.String) value); return true;
            case "snapshotLockingModeCustomName": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotLockingModeCustomName((java.lang.String) value); return true;
            case "snapshotLockTimeoutMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotLockTimeoutMs((long) value); return true;
            case "snapshotMaxThreads": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotMaxThreads((int) value); return true;
            case "snapshotMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotMode((java.lang.String) value); return true;
            case "snapshotModeConfigurationBasedSnapshotData": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotModeConfigurationBasedSnapshotData((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotOnDataError": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotModeConfigurationBasedSnapshotOnDataError((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotOnSchemaError": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotModeConfigurationBasedSnapshotOnSchemaError((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotSchema": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotModeConfigurationBasedSnapshotSchema((boolean) value); return true;
            case "snapshotModeConfigurationBasedStartStream": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotModeConfigurationBasedStartStream((boolean) value); return true;
            case "snapshotModeCustomName": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotModeCustomName((java.lang.String) value); return true;
            case "snapshotQueryMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotQueryMode((java.lang.String) value); return true;
            case "snapshotQueryModeCustomName": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotQueryModeCustomName((java.lang.String) value); return true;
            case "snapshotSelectStatementOverrides": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotSelectStatementOverrides((java.lang.String) value); return true;
            case "snapshotTablesOrderByRowCount": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotTablesOrderByRowCount((java.lang.String) value); return true;
            case "sourceinfoStructMaker": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSourceinfoStructMaker((java.lang.String) value); return true;
            case "statusUpdateIntervalMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setStatusUpdateIntervalMs((int) value); return true;
            case "streamingDelayMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setStreamingDelayMs((long) value); return true;
            case "tableExcludeList": getOrCreateConfiguration((DebeziumPostgresComponent) component).setTableExcludeList((java.lang.String) value); return true;
            case "tableIgnoreBuiltin": getOrCreateConfiguration((DebeziumPostgresComponent) component).setTableIgnoreBuiltin((boolean) value); return true;
            case "tableIncludeList": getOrCreateConfiguration((DebeziumPostgresComponent) component).setTableIncludeList((java.lang.String) value); return true;
            case "timePrecisionMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setTimePrecisionMode((java.lang.String) value); return true;
            case "tombstonesOnDelete": getOrCreateConfiguration((DebeziumPostgresComponent) component).setTombstonesOnDelete((boolean) value); return true;
            case "topicNamingStrategy": getOrCreateConfiguration((DebeziumPostgresComponent) component).setTopicNamingStrategy((java.lang.String) value); return true;
            case "topicPrefix": getOrCreateConfiguration((DebeziumPostgresComponent) component).setTopicPrefix((java.lang.String) value); return true;
            case "transactionMetadataFactory": getOrCreateConfiguration((DebeziumPostgresComponent) component).setTransactionMetadataFactory((java.lang.String) value); return true;
            case "unavailableValuePlaceholder": getOrCreateConfiguration((DebeziumPostgresComponent) component).setUnavailableValuePlaceholder((java.lang.String) value); return true;
            case "xminFetchIntervalMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setXminFetchIntervalMs((long) value); return true;
            default: return false;
            }
        }

    protected void scheduleDelayedStart() {
        Runnable startRunnable = new Runnable() {
            @Override
            public void run() {
                try {
                    doStart();
                } catch (Exception e) {
                    LOG.warn("Ignoring an exception caught in the startup connection poller thread.", e);
                }
            }
        };
        LOG.info("Delaying XMPP consumer startup for endpoint {}. Trying again in {} seconds.",
                URISupport.sanitizeUri(endpoint.getEndpointUri()), endpoint.getConnectionPollDelay());
        getExecutor().schedule(startRunnable, endpoint.getConnectionPollDelay(), TimeUnit.SECONDS);
    }

    private boolean hasTriggerChanged(Trigger oldTrigger, Trigger newTrigger) {
        if (newTrigger instanceof CronTrigger && oldTrigger instanceof CronTrigger) {
            CronTrigger newCron = (CronTrigger) newTrigger;
            CronTrigger oldCron = (CronTrigger) oldTrigger;
            return !newCron.getCronExpression().equals(oldCron.getCronExpression());
        } else if (newTrigger instanceof SimpleTrigger && oldTrigger instanceof SimpleTrigger) {
            SimpleTrigger newSimple = (SimpleTrigger) newTrigger;
            SimpleTrigger oldSimple = (SimpleTrigger) oldTrigger;
            return newSimple.getRepeatInterval() != oldSimple.getRepeatInterval()
                    || newSimple.getRepeatCount() != oldSimple.getRepeatCount();
        } else {
            return !newTrigger.getClass().equals(oldTrigger.getClass()) || !newTrigger.equals(oldTrigger);
        }
    }

    public void stop() {
        lock.lock();
        try {
            if (status == FAILED) {
                logger().trace("Service: {} failed and regarded as already stopped", this);
                return;
            }
            if (status == STOPPED || status == SHUTTING_DOWN || status == SHUTDOWN) {
                logger().trace("Service: {} already stopped", this);
                return;
            }
            if (status == STOPPING) {
                logger().trace("Service: {} already stopping", this);
                return;
            }
            status = STOPPING;
            logger().trace("Stopping service: {}", this);
            try (AutoCloseable ignored = doLifecycleChange()) {
                doStop();
                status = STOPPED;
                logger().trace("Stopped: {} service", this);
            } catch (Exception e) {
                logger().trace("Error while stopping service: {}", this, e);
                fail(e);
            }
        } finally {
            lock.unlock();
        }
    }

    public void configureAuthentication(
            AuthenticationConfig authenticationConfig,
            HttpManagementServerConfigurationProperties properties) {

        String path
                = isNotEmpty(properties.getAuthenticationPath()) ? properties.getAuthenticationPath() : properties.getPath();
         
        if ("/".equals(path)) {
            path = "/*";
        }
        String realm = properties.getAuthenticationRealm() != null ? properties.getAuthenticationRealm() : null;

        AuthenticationConfigEntry entry = new AuthenticationConfigEntry();
        entry.setPath(path);
        entry.setAuthenticationHandlerFactory(new AuthenticationHandlerFactory() {
            @Override
            public <T extends AuthenticationProvider> AuthenticationHandler createAuthenticationHandler(
                    T authenticationProvider) {
                JWTAuth authProvider = (JWTAuth) authenticationProvider;
                return JWTAuthHandler.create(authProvider, realm);
            }
        });
        entry.setAuthenticationProviderFactory(vertx -> JWTAuth.create(
                vertx,
                new JWTAuthOptions(
                        new JsonObject().put("keyStore", new JsonObject()
                                .put("type", properties.getJwtKeystoreType())
                                .put("path", properties.getJwtKeystorePath())
                                .put("password", properties.getJwtKeystorePassword())))));

        authenticationConfig.getEntries().add(entry);
        authenticationConfig.setEnabled(true);
    }

    protected String doCallText(Map<String, Object> options) {
        StringBuilder sb = new StringBuilder();

        if (propertiesFunction != null) {
            sb.append("Kubernetes Config maps Cluster:");
            sb.append(String.format("\n    Master Url: %s", propertiesFunction.getClient().getMasterUrl()));
            sb.append("\n    Login: OAuth Token");
            KubernetesVaultConfiguration kubernetes
                    = getCamelContext().getVaultConfiguration().getKubernetesVaultConfiguration();
            if (kubernetes != null) {
                sb.append(String.format("\n    Refresh Enabled: %s", kubernetes.isRefreshEnabled()));
            }
            if (cmRefreshTask != null) {
                Instant start = cmRefreshTask.getStartingTime();
                String s = start != null ? TimeUtils.printSince(start.toEpochMilli()) : "none";
                sb.append(String.format("\n    Running Since: %s", s));
            }
            List<String> sorted = new ArrayList<>();
            if (kubernetes != null) {
                sb.append("\n\nSecrets in use:");

                sorted = new ArrayList<>(List.of(kubernetes.getSecrets().split(",")));
                Collections.sort(sorted);
            }

            for (String sec : sorted) {
                sb.append(String.format("\n    %s", sec));
            }
        }

        return sb.toString();
    }

    public int forceDiscardingOfGroup(String key) {
         
        int total = 0;

        lock.lock();
        try {
            Exchange exchange = aggregationRepository.get(camelContext, key);
            if (exchange != null) {
                total = 1;
                LOG.trace("Force discarded triggered for correlation key: {}", key);
                 
                onCompletion(key, exchange, exchange, false, true);
            }
        } finally {
            lock.unlock();
        }
        LOG.trace("Completed force discarded of group {}", key);

        if (total > 0) {
            LOG.debug("Forcing discarding of group {} with {} exchanges", key, total);
        }
        return total;
    }

    private static void configureProxyAuthorizationPolicy(
            ServiceNowConfiguration configuration, WebClient client) {

        ProxyAuthorizationPolicy proxyPolicy = configuration.getProxyAuthorizationPolicy();
        if (proxyPolicy == null) {
            String username = configuration.getProxyUserName();
            String password = configuration.getProxyPassword();

            if (username != null && password != null) {
                proxyPolicy = new ProxyAuthorizationPolicy();
                proxyPolicy.setAuthorizationType("Basic");
                proxyPolicy.setUserName(username);
                proxyPolicy.setPassword(password);
            }
        }

        if (proxyPolicy != null) {
            WebClient.getConfig(client).getHttpConduit().setProxyAuthorization(proxyPolicy);
        }
    }

    public Producer createProducer(
            CamelContext camelContext, String host,
            String verb, String basePath, String uriTemplate, String queryParameters,
            String consumes, String produces, RestConfiguration configuration, Map<String, Object> parameters)
            throws Exception {

         
        basePath = FileUtil.stripLeadingSeparator(basePath);
        uriTemplate = FileUtil.stripLeadingSeparator(uriTemplate);

         
        String url = host;
        if (!ObjectHelper.isEmpty(basePath)) {
            url += "/" + basePath;
        }
        if (!ObjectHelper.isEmpty(uriTemplate)) {
            url += "/" + uriTemplate;
        }

        RestConfiguration config = configuration;
        if (config == null) {
            config = CamelContextHelper.getRestConfiguration(getCamelContext(), null, "http");
        }

        Map<String, Object> map = new HashMap<>();
         
        if (config.getProducerComponent() == null || config.getProducerComponent().equals("http")) {
             
            map.put("httpMethod", verb);
            if (config.getEndpointProperties() != null && !config.getEndpointProperties().isEmpty()) {
                map.putAll(config.getEndpointProperties());
            }
        }

        url = HttpUtil.recreateUrl(map, url);

        parameters = parameters != null ? new HashMap<>(parameters) : new HashMap<>();

         
         
         
        RestProducerFactoryHelper.setupComponentFor(url, camelContext, (Map<String, Object>) parameters.remove("component"));

        HttpEndpoint endpoint = (HttpEndpoint) camelContext.getEndpoint(url, parameters);

        String path = uriTemplate != null ? uriTemplate : basePath;

        HeaderFilterStrategy headerFilterStrategy
                = resolveAndRemoveReferenceParameter(parameters, "headerFilterStrategy", HeaderFilterStrategy.class);
        if (headerFilterStrategy != null) {
            endpoint.setHeaderFilterStrategy(headerFilterStrategy);
        } else {
            endpoint.setHeaderFilterStrategy(new HttpRestHeaderFilterStrategy(path, queryParameters));
        }
         
        ServiceHelper.startService(endpoint);

        return endpoint.createProducer();
    }

    private void doHttpRequestWithJobResponse(JobResponseCallback callback, Request request) {
        doHttpRequest(request, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> responseHeaders, SalesforceException ex) {
                if (ex != null) {
                    callback.onResponse(null, responseHeaders, ex);
                    return;
                }
                Job responseJob = null;
                try {
                    responseJob = DefaultBulkApiV2Client.this.unmarshalResponse(response, request,
                            Job.class);
                } catch (SalesforceException e) {
                    ex = e;
                }
                callback.onResponse(responseJob, responseHeaders, ex);
            }
        });
    }

    protected void execute(boolean dto) throws MojoExecutionException {
        if (skip) {
            return;
        }

        OpenAPI openapi = new OpenAPIV3Parser().read(specificationUri);

        if (openapi == null) {
            throw new MojoExecutionException(
                    "Unable to generate REST DSL OpenApi sources from specification: "
                                             + specificationUri
                                             + ", make sure that the specification is available at the given URI");
        }

        final RestDslYamlGenerator generator = RestDslGenerator.toYaml(openapi);

        if (ObjectHelper.isNotEmpty(basePath)) {
            generator.withBasePath(basePath);
        }

        if (ObjectHelper.isNotEmpty(filterOperation)) {
            generator.withOperationFilter(filterOperation);
        }
        if (dto) {
            if (modelPackage != null) {
                generator.withDtoPackageName(modelPackage);
            }
        }

        if (ObjectHelper.isNotEmpty(destinationGenerator)) {
            final DestinationGenerator destinationGeneratorObject = createDestinationGenerator();
            generator.withDestinationGenerator(destinationGeneratorObject);
        } else if (ObjectHelper.isNotEmpty(destinationToSyntax)) {
            generator.withDestinationToSyntax(destinationToSyntax);
        }

        if (restConfiguration) {
            generator.withRestComponent(findAppropriateComponent());
            if (clientRequestValidation) {
                generator.withClientRequestValidation();
            }
            if (ObjectHelper.isNotEmpty(apiContextPath)) {
                generator.withApiContextPath(apiContextPath);
            }
        }

        try {
            final CamelContext camel = new DefaultCamelContext();
            final String yaml = generator.generate(camel);

             
            new File(outputDirectory).mkdirs();
            final File out = new File(outputDirectory, fileName);

            try (FileOutputStream fos = new FileOutputStream(out)) {
                fos.write(yaml.getBytes());
            }
        } catch (final Exception e) {
            throw new MojoExecutionException(
                    "Unable to generate REST DSL OpenApi sources from specification: " + specificationUri, e);
        }
    }

    public ASN1GenericIterator(Class<T> clazz, InputStream inputStream) {
        if (inputStream instanceof ASN1InputStream) {
            this.asn1InputStream = (ASN1InputStream) inputStream;
        } else {
            this.asn1InputStream = new ASN1InputStream(inputStream);
        }
        this.parent = null;
        this.clazz = clazz;
    }

        Object next(boolean first) {
            Object answer = image;
             
            if (scanner.hasNext()) {
                image = getNext(first);
            } else {
                image = null;
            }

            if (answer == null) {
                 
                answer = image;
            }
            return answer;
        }

    protected void doInit() throws Exception {
        DefaultExchangeFormatter def = new DefaultExchangeFormatter();
        def.setShowExchangePattern(true);
        def.setSkipBodyLineSeparator(true);
        def.setShowBody(true);
        def.setShowBodyType(true);
        def.setStyle(DefaultExchangeFormatter.OutputStyle.Default);
        def.setMaxChars(10000);
        this.defaultExchangeFormatter = def;
    }

    public DocFlavor forMimeTypeUTF8(String flavor, String mimeType) {
        if (mimeType.equalsIgnoreCase("TEXT_HTML_UTF_16BE")) {
            if (flavor.equalsIgnoreCase("DocFlavor.BYTE_ARRAY")) {
                d = DocFlavor.BYTE_ARRAY.TEXT_HTML_UTF_8;
            } else if (flavor.equalsIgnoreCase("DocFlavor.INPUT_STREAM")) {
                d = DocFlavor.INPUT_STREAM.TEXT_HTML_UTF_8;
            } else if (flavor.equalsIgnoreCase("DocFlavor.URL")) {
                d = DocFlavor.URL.TEXT_HTML_UTF_8;
            }
        } else {
            if (flavor.equalsIgnoreCase("DocFlavor.BYTE_ARRAY")) {
                d = DocFlavor.BYTE_ARRAY.TEXT_PLAIN_UTF_8;
            } else if (flavor.equalsIgnoreCase("DocFlavor.INPUT_STREAM")) {
                d = DocFlavor.INPUT_STREAM.TEXT_PLAIN_UTF_8;
            } else if (flavor.equalsIgnoreCase("DocFlavor.URL")) {
                d = DocFlavor.URL.TEXT_PLAIN_UTF_8;
            }
        }

        return d;
    }

    protected void decode(ChannelHandlerContext ctx, AddressedEnvelope<Object, InetSocketAddress> msg, List<Object> out)
            throws Exception {
        if (msg.content() instanceof ByteBuf) {
            ByteBuf payload = (ByteBuf) msg.content();
            AddressedEnvelope<Object, InetSocketAddress> addressedEnvelop
                    = new DefaultAddressedEnvelope<>(payload.toString(charset), msg.recipient(), msg.sender());
            out.add(addressedEnvelop);
        } else {
            LOG.debug("Ignoring message content as it is not an io.netty.buffer.ByteBuf instance.");
        }
    }

    private static Map<String, Object> checkValidExchangePropertyObjects(
            String type, Exchange exchange, Map<String, Object> map, boolean allowSerializedValues) {
        if (map == null) {
            return null;
        }

        Map<String, Object> result = new LinkedHashMap<>();
        for (Map.Entry<String, Object> entry : map.entrySet()) {

             
            if (entry.getValue() == null) {
                continue;
            }

            Object value = getValidExchangePropertyValue(entry.getKey(), entry.getValue(), allowSerializedValues);
            if (value != null) {
                Serializable converted
                        = exchange.getContext().getTypeConverter().convertTo(Serializable.class, exchange, value);
                if (converted != null) {
                    result.put(entry.getKey(), converted);
                } else {
                    logCannotSerializeObject(type, entry.getKey(), entry.getValue());
                }
            } else {
                logInvalidExchangePropertyValue(type, entry.getKey(), entry.getValue());
            }
        }

        return result;
    }

    private ExecStartCmd executeExecStartRequest(DockerClient client, Message message) {

        LOG.debug("Executing Docker Exec Start Request");

        String execId = DockerHelper.getProperty(DockerConstants.DOCKER_EXEC_ID, configuration, message, String.class);

        ObjectHelper.notNull(execId, "Exec ID must be specified");

        ExecStartCmd execStartCmd = client.execStartCmd(execId);

        Boolean detach = DockerHelper.getProperty(DockerConstants.DOCKER_DETACH, configuration, message, Boolean.class);

        if (detach != null) {
            execStartCmd.withDetach(detach);
        }

        Boolean tty = DockerHelper.getProperty(DockerConstants.DOCKER_TTY, configuration, message, Boolean.class);

        if (tty != null) {
            execStartCmd.withTty(tty);
        }

        return execStartCmd;

    }

    protected void encode(
            ChannelHandlerContext ctx, AddressedEnvelope<Object, InetSocketAddress> msg,
            List<Object> out)
            throws Exception {
        if (msg.content() instanceof Serializable) {
            Serializable payload = (Serializable) msg.content();
            ByteBuf buf = ctx.alloc().buffer();
            delegateObjectEncoder.encode(ctx, payload, buf);
            AddressedEnvelope<Object, InetSocketAddress> addressedEnvelop
                    = new DefaultAddressedEnvelope<>(buf, msg.recipient(), msg.sender());
            out.add(addressedEnvelop);
        } else {
            LOG.debug("Ignoring message content as it is not a java.io.Serializable instance.");
        }
    }

    private int readTraceFiles(Map<Long, Pid> pids) throws Exception {
        int lines = 0;

        for (Pid pid : pids.values()) {
            if (pid.reader == null) {
                Path file = getTraceFile(pid.pid);
                if (Files.exists(file)) {
                    pid.reader = new LineNumberReader(Files.newBufferedReader(file));
                    if (tail == 0) {
                         
                        long size = Files.size(file);
                        pid.reader.skip(size);
                    }
                }
            }
            if (pid.reader != null) {
                String line;
                do {
                    try {
                        line = pid.reader.readLine();
                        if (line != null) {
                            lines++;
                             
                            if (pid.fifo == null || pid.fifo instanceof ArrayBlockingQueue) {
                                pid.fifo = new ArrayDeque<>();
                            }
                            pid.fifo.offer(line);
                        }
                    } catch (IOException e) {
                         
                        line = null;
                    }
                } while (line != null);
            }
        }

        return lines;
    }

    private void deleteByIds(Exchange exchange) throws Exception {
        final Message in = exchange.getMessage();
        List elements = in.getMandatoryBody(List.class);
        String indexName = getEndpoint().getConfiguration().getIndexName();

        if (in.getHeader(PineconeVectorDbHeaders.INDEX_NAME, String.class) != null) {
            indexName = in.getHeader(PineconeVectorDbHeaders.INDEX_NAME, String.class);
        }

        Index index = this.client.getIndexConnection(indexName);

        DeleteResponse result
                = index.deleteByIds(elements);

        populateDeleteResponse(result, exchange);
    }

    private void delayOrScheduleLockRelease(Runnable r) throws InterruptedException {
        if (readLockIdempotentReleaseDelay > 0 && readLockIdempotentReleaseExecutorService != null) {
            LOG.debug("Scheduling read lock release task to run asynchronous delayed after {} millis",
                    readLockIdempotentReleaseDelay);
            readLockIdempotentReleaseExecutorService.schedule(r, readLockIdempotentReleaseDelay, TimeUnit.MILLISECONDS);
        } else if (readLockIdempotentReleaseDelay > 0) {
            LOG.debug("Delaying read lock release task {} millis", readLockIdempotentReleaseDelay);
            Thread.sleep(readLockIdempotentReleaseDelay);
            r.run();
        } else {
            r.run();
        }
    }

    private static Map<String, Object> checkValidHeaderObjects(
            String type, Exchange exchange, Map<String, Object> map, boolean allowSerializedHeaders) {
        if (map == null) {
            return null;
        }

        Map<String, Object> result = new LinkedHashMap<>();
        for (Map.Entry<String, Object> entry : map.entrySet()) {

             
            if (entry.getValue() == null) {
                continue;
            }

            Object value = getValidHeaderValue(entry.getKey(), entry.getValue(), allowSerializedHeaders);
            if (value != null) {
                Serializable converted
                        = exchange.getContext().getTypeConverter().convertTo(Serializable.class, exchange, value);
                if (converted != null) {
                    result.put(entry.getKey(), converted);
                } else {
                    logCannotSerializeObject(type, entry.getKey(), entry.getValue());
                }
            } else {
                logInvalidHeaderValue(type, entry.getKey(), entry.getValue());
            }
        }

        return result;
    }

    static Map<String, List<String>> determineHeaders(final Exchange exchange) {
        final Message inboundMessage = exchange.getIn();

        final Map<String, Object> headers = inboundMessage.getHeaders();

        final Map<String, List<String>> answer = new HashMap<>();
        for (final String headerName : headers.keySet()) {
            final String headerNameLowercase = headerName.toLowerCase(Locale.US);
            if (headerNameLowercase.startsWith("sforce") || headerNameLowercase.startsWith("x-sfdc")) {
                final Object headerValue = inboundMessage.getHeader(headerName);

                if (headerValue instanceof String) {
                    answer.put(headerName, Collections.singletonList((String) headerValue));
                } else if (headerValue instanceof String[]) {
                    answer.put(headerName, Arrays.asList((String[]) headerValue));
                } else if (headerValue instanceof Collection) {
                    answer.put(headerName,
                            ((Collection<?>) headerValue).stream().map(String::valueOf).collect(Collectors.<String> toList()));
                } else {
                    throw new IllegalArgumentException(
                            "Given value for header `" + headerName + "`, is not String, String array or a Collection");
                }
            }
        }
        return answer;
    }

    public void execute(Exchange exchange) throws SmppException {
        CancelSm cancelSm = createCancelSm(exchange);

        if (log.isDebugEnabled()) {
            log.debug("Canceling a short message for exchange id '{}' and message id '{}'",
                    exchange.getExchangeId(), cancelSm.getMessageId());
        }

        try {
            session.cancelShortMessage(
                    cancelSm.getServiceType(),
                    cancelSm.getMessageId(),
                    TypeOfNumber.valueOf(cancelSm.getSourceAddrTon()),
                    NumberingPlanIndicator.valueOf(cancelSm.getSourceAddrNpi()),
                    cancelSm.getSourceAddr(),
                    TypeOfNumber.valueOf(cancelSm.getDestAddrTon()),
                    NumberingPlanIndicator.valueOf(cancelSm.getDestAddrNpi()),
                    cancelSm.getDestinationAddress());
        } catch (Exception e) {
            throw new SmppException(e);
        }

        if (log.isDebugEnabled()) {
            log.debug("Cancel a short message for exchange id '{}' and message id '{}'",
                    exchange.getExchangeId(), cancelSm.getMessageId());
        }

        Message message = ExchangeHelper.getResultMessage(exchange);
        message.setHeader(SmppConstants.ID, cancelSm.getMessageId());
    }

    public void transform(Message message, DataType fromType, DataType toType) {
        final Map<String, Object> headers = message.getHeaders();

        CloudEvent cloudEvent = CloudEvents.v1_0;
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_ID, message.getExchange().getExchangeId());
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_VERSION, cloudEvent.version());
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TYPE, "org.apache.camel.event.google.sheets.stream.consume");

        if (message.getHeaders().containsKey(GoogleSheetsStreamConstants.SPREADSHEET_ID)) {
            headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SOURCE,
                    "google.sheets.stream." + message.getHeader(GoogleSheetsStreamConstants.SPREADSHEET_ID, String.class));
        }

        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SUBJECT, message.getHeader(GoogleSheetsStreamConstants.SPREADSHEET_URL));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TIME, cloudEvent.getEventTime(message.getExchange()));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_CONTENT_TYPE, CloudEvent.APPLICATION_OCTET_STREAM_MIME_TYPE);
    }

    private String getAlgorithmName(String algorithm) {
        try {
            return PQCSignatureAlgorithms.valueOf(algorithm).getAlgorithm();
        } catch (IllegalArgumentException e1) {
            try {
                return PQCKeyEncapsulationAlgorithms.valueOf(algorithm).getAlgorithm();
            } catch (IllegalArgumentException e2) {
                return algorithm;
            }
        }
    }

    public void receive(String requestUriPattern, HttpRequestHandler handler) {
        if (listenerThread != null) {
            lock.lock();
            try {
                listenerThread.registerHandler(requestUriPattern, handler);
            } finally {
                lock.unlock();
            }
        }
    }

    public Integer doProcessWatchCall() throws Exception {
        List<Row> rows = new ArrayList<>();

        List<Long> pids = findPids(name);
        ProcessHandle.allProcesses()
                .filter(ph -> pids.contains(ph.pid()))
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                    if (root != null) {
                        JsonObject context = (JsonObject) root.get("context");
                        if (context == null) {
                            return;
                        }
                        JsonArray array = (JsonArray) root.get("routes");
                        for (int i = 0; i < array.size(); i++) {
                            JsonObject o = (JsonObject) array.get(i);
                            Row row = new Row();
                            row.name = context.getString("name");
                            if ("CamelJBang".equals(row.name)) {
                                row.name = ProcessHelper.extractName(root, ph);
                            }
                            row.pid = Long.toString(ph.pid());
                            row.routeId = o.getString("routeId");
                            row.group = o.getString("group");
                            row.description = o.getString("description");
                            row.note = o.getString("note");
                            row.nodePrefixId = o.getString("nodePrefixId");
                            row.processor = o.getString("from");
                            row.source = o.getString("source");
                            row.state = o.getString("state");
                            Map<String, ?> stats = o.getMap("statistics");
                            if (stats != null) {
                                row.total = stats.get("exchangesTotal").toString();
                                Object num = stats.get("remoteExchangesTotal");
                                if (num != null) {
                                    row.totalRemote = num.toString();
                                }
                                row.inflight = stats.get("exchangesInflight").toString();
                                num = stats.get("remoteExchangesInflight");
                                if (num != null) {
                                    row.inflightRemote = num.toString();
                                }
                                row.failed = stats.get("exchangesFailed").toString();
                                num = stats.get("remoteExchangesFailed");
                                if (num != null) {
                                    row.failedRemote = num.toString();
                                }
                                row.mean = stats.get("meanProcessingTime").toString();
                                if ("-1".equals(row.mean)) {
                                    row.mean = null;
                                }
                                row.max = stats.get("maxProcessingTime").toString();
                                row.min = stats.get("minProcessingTime").toString();
                                Object last = stats.get("lastProcessingTime");
                                if (last != null) {
                                    row.last = last.toString();
                                }
                                last = stats.get("deltaProcessingTime");
                                if (last != null) {
                                    row.delta = last.toString();
                                }
                                last = stats.get("lastCreatedExchangeTimestamp");
                                if (last != null) {
                                    long time = Long.parseLong(last.toString());
                                    row.sinceLastStarted = TimeUtils.printSince(time);
                                }
                                last = stats.get("lastCompletedExchangeTimestamp");
                                if (last != null) {
                                    long time = Long.parseLong(last.toString());
                                    row.sinceLastCompleted = TimeUtils.printSince(time);
                                }
                                last = stats.get("lastFailedExchangeTimestamp");
                                if (last != null) {
                                    long time = Long.parseLong(last.toString());
                                    row.sinceLastFailed = TimeUtils.printSince(time);
                                }
                            }

                            boolean add = true;
                            if (mean > 0 && (row.mean == null || Long.parseLong(row.mean) < mean)) {
                                add = false;
                            }
                            if (limit > 0 && rows.size() >= limit) {
                                add = false;
                            }
                            if (add) {
                                rows.add(row);
                                List<JsonObject> list = o.getCollection("processors");
                                if (list != null) {
                                    addProcessors(row, rows, list);
                                }
                            }
                        }
                    }
                });

         
        if (running || filter != null || group != null) {
            rows.removeIf(r -> {
                boolean keep = true;
                if (filter != null) {
                    keep = PatternHelper.matchPatterns(r.processorId, filter);
                }
                if (!keep && filter != null) {
                    for (String f : filter) {
                        if (!keep) {
                            String w = f.endsWith("*") ? f : f + "*";  
                            keep = PatternHelper.matchPattern(r.processor, w);
                        }
                    }
                }
                 
                if (keep && group != null) {
                    keep = PatternHelper.matchPatterns(r.group, group);
                }
                if (keep && running) {
                    keep = "Started".equals(r.state);
                }
                return !keep;
            });
        }

         
        rows.sort(this::sortRow);

        if (!rows.isEmpty()) {
            printTable(rows);
        }

        return 0;
    }

    protected String doCallText(Map<String, Object> options) {
        StringBuilder sb = new StringBuilder();

        if (rr != null) {
            for (RestRegistry.RestService rs : rr.listAllRestServices()) {
                if (!sb.isEmpty()) {
                    sb.append("\n");
                }
                sb.append(String.format("\n    Url: %s", rs.getUrl()));
                sb.append(String.format("\n    Method: %s", rs.getMethod()));
                sb.append(String.format("\n    State: %s", rs.getState()));
                if (rs.getConsumes() != null) {
                    sb.append(String.format("\n    Consumes: %s", rs.getConsumes()));
                }
                if (rs.getProduces() != null) {
                    sb.append(String.format("\n    Produces: %s", rs.getProduces()));
                }
                if (rs.getInType() != null) {
                    sb.append(String.format("\n    In Type: %s", rs.getInType()));
                }
                if (rs.getOutType() != null) {
                    sb.append(String.format("\n    Out Type: %s", rs.getOutType()));
                }
                if (rs.getDescription() != null) {
                    sb.append(String.format("\n    Description: %s", rs.getDescription()));
                }
            }
            sb.append("\n");
        }

        return sb.toString();
    }

    public InputStream loadResourceAsStream(String uri) {
        resourceResolverListeners.forEach(l -> l.onLoadResourceAsStream(uri));

        InputStream answer = null;
        try {
            answer = super.loadResourceAsStream(uri);
        } catch (Exception e) {
             
        }

        if (answer == null) {
             
            MavenGav gav = knownDependenciesResolver.mavenGavForClass(uri);
            if (gav == null) {
                 
                 
                String last = StringHelper.afterLast(uri, ".", uri);
                PojoBeanModel model = catalog.pojoBeanModel(last);
                if (model != null && uri.equals(model.getJavaType())) {
                    gav = MavenGav.fromCoordinates(model.getGroupId(), model.getArtifactId(), model.getVersion(), null, null);
                }
            }
            if (gav != null) {
                if (!downloader.alreadyOnClasspath(gav.getGroupId(), gav.getArtifactId(),
                        gav.getVersion())) {
                    downloader.downloadDependency(gav.getGroupId(), gav.getArtifactId(),
                            gav.getVersion());
                }
                try {
                    answer = super.loadResourceAsStream(uri);
                } catch (Exception e) {
                     
                }
            }
        }

        return answer;
    }

    public boolean register(PlatformHttpPlugin plugin) {
        if (getPlugin(plugin.getId()).isPresent()) {
            return false;
        }

        boolean result = plugins.add(plugin);
        if (result) {
            CamelContextAware.trySetCamelContext(plugin, camelContext);
            ServiceHelper.startService(plugin);
            LOG.debug("platform-http-plugin with id {} successfully registered", plugin.getId());
        }
        return result;
    }

    protected void doService(HttpServletRequest request, HttpServletResponse response) {
        log.trace("Service: {}", request);
        try {
            handleDoService(request, response);
        } catch (Exception e) {
             
            log.warn("Error handling request due to: {}", e.getMessage(), e);
            try {
                if (!response.isCommitted()) {
                    response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
                }
            } catch (Exception e1) {
                 
            }
        }
    }

    protected void prepareDataFormatConfig(Map<String, Object> properties) {
        if (definition.getLibrary() == ProtobufLibrary.GoogleProtobuf) {
            if (definition.getInstanceClass() == null) {
                if (definition.getUnmarshalType() != null) {
                    properties.put("instanceClass", definition.getUnmarshalType().getName());
                } else if (definition.getUnmarshalTypeName() != null) {
                    properties.put("instanceClass", definition.getUnmarshalTypeName());
                }
            } else {
                properties.put("instanceClass", definition.getInstanceClass());
            }
            properties.put("contentTypeFormat", definition.getContentTypeFormat());
            properties.put("defaultInstance", definition.getDefaultInstance());
        } else if (definition.getLibrary() == ProtobufLibrary.Jackson) {
            properties.put("objectMapper", asRef(definition.getObjectMapper()));
            if (definition.getUseDefaultObjectMapper() == null) {
                 
                properties.put("useDefaultObjectMapper", "true");
            } else {
                properties.put("useDefaultObjectMapper", definition.getUseDefaultObjectMapper());
            }
            properties.put("autoDiscoverObjectMapper", definition.getAutoDiscoverObjectMapper());
            properties.put("jsonView", or(definition.getJsonView(), definition.getJsonViewTypeName()));
            properties.put("unmarshalType", or(
                    or(definition.getUnmarshalType(), definition.getUnmarshalTypeName()), definition.getInstanceClass()));
            properties.put("include", definition.getInclude());
            properties.put("allowJmsType", definition.getAllowJmsType());
            properties.put("collectionType", or(definition.getCollectionType(), definition.getCollectionTypeName()));
            properties.put("useList", definition.getUseList());
            properties.put("moduleClassNames", definition.getModuleClassNames());
            properties.put("moduleRefs", definition.getModuleRefs());
            properties.put("enableFeatures", definition.getEnableFeatures());
            properties.put("disableFeatures", definition.getDisableFeatures());
            properties.put("allowUnmarshallType", definition.getAllowUnmarshallType());
            properties.put("schemaResolver", asRef(definition.getSchemaResolver()));
            properties.put("autoDiscoverSchemaResolver", definition.getAutoDiscoverSchemaResolver());
        }
    }

    public static Method findMethod(Class<?> clazz, String name, Class<?>... paramTypes) {
        ObjectHelper.notNull(clazz, "Class must not be null");
        ObjectHelper.notNull(name, "Method name must not be null");
        Class<?> searchType = clazz;
        while (searchType != null) {
            Method[] methods = searchType.isInterface() ? searchType.getMethods() : searchType.getDeclaredMethods();
            for (Method method : methods) {
                if (name.equals(method.getName())
                        && (paramTypes == null || Arrays.equals(paramTypes, method.getParameterTypes()))) {
                    return method;
                }
            }
            searchType = searchType.getSuperclass();
        }
        return null;
    }

        public void onPart(String channel, IRCUser user, String msg) {
            if (configuration.isOnPart()) {
                Exchange exchange = createOnPartExchange(channel, user, msg);
                try {
                    getProcessor().process(exchange);
                } catch (Exception e) {
                    handleException(e);
                }
            }
        }

    public static <T> Supplier<T> memorize(ThrowingSupplier<T, ? extends Exception> supplier, Consumer<Exception> consumer) {
        final AtomicReference<T> valueHolder = new AtomicReference<>();
        return new Supplier<>() {
            @Override
            public T get() {
                T supplied = valueHolder.get();
                if (supplied == null) {
                    synchronized (valueHolder) {
                        supplied = valueHolder.get();
                        if (supplied == null) {
                            try {
                                supplied = Objects.requireNonNull(supplier.get(), "Supplier should not return null");
                                valueHolder.lazySet(supplied);
                            } catch (Exception e) {
                                consumer.accept(e);
                            }
                        }
                    }
                }
                return supplied;
            }
        };
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulSessionProducer target = (org.apache.camel.component.consul.endpoint.ConsulSessionProducer) obj;
        switch (key) {
        case "create":
        case "CREATE": target.create(exchange.getMessage()); return null;
        case "destroy":
        case "DESTROY": target.destroy(exchange.getMessage()); return null;
        case "info":
        case "INFO": target.info(exchange.getMessage()); return null;
        case "list":
        case "LIST": target.list(exchange.getMessage()); return null;
        case "renew":
        case "RENEW": target.renew(exchange.getMessage()); return null;
        default: return null;
        }
    }

    protected AbstractMessageListenerContainer createListenerContainer() throws Exception {
        if (endpoint.getConfiguration().getReplyToConsumerType() == ConsumerType.Default) {
            return createDefaultListenerContainer();
        } else if (endpoint.getConfiguration().getReplyToConsumerType() == ConsumerType.Simple) {
            return createSimpleListenerContainer();
        } else {
            return getAbstractMessageListenerContainer(endpoint);
        }
    }

    private SearchResponse<TDocument> firstSearch() {
        SearchResponse<TDocument> searchResponse;
        try {
            searchResponse = esClient.search(searchRequest, documentClass);
            requestCount++;
        } catch (IOException e) {
            throw new IllegalStateException(e);
        }
        return searchResponse;
    }

    protected ScheduledExecutorService getExecutorService(
            ScheduledExecutorService executorService, String executorServiceRef) {
        lock.lock();
        try {
            if (executorService == null || executorService.isShutdown()) {
                 
                 
                if (executorServiceRef != null) {
                    executorService = lookupByNameAndType(executorServiceRef, ScheduledExecutorService.class);
                    if (executorService == null) {
                        ExecutorServiceManager manager = camelContext.getExecutorServiceManager();
                        ThreadPoolProfile profile = manager.getThreadPoolProfile(executorServiceRef);
                        executorService = manager.newScheduledThreadPool(this, executorServiceRef, profile);
                    }
                    if (executorService == null) {
                        throw new IllegalArgumentException("ExecutorService " + executorServiceRef + " not found in registry.");
                    }
                } else {
                     
                     
                     
                     
                    executorService = null;
                }
            }
            return executorService;
        } finally {
            lock.unlock();
        }
    }

    protected List<String> determineSignaturenUserIds(Exchange exchange) {
        String userid = findSignatureKeyUserid(exchange);
        List<String> userids = findSignatureKeyUserids(exchange);
         
        List<String> result;
        if (userid != null) {
            if (userids == null || userids.isEmpty()) {
                result = Collections.singletonList(userid);
            } else {
                result = new ArrayList<>(userids.size() + 1);
                result.add(userid);
                result.addAll(userids);
            }
        } else {
             
            result = userids;
        }
        return result;
    }

    private void stopConsumer(Route route) {
        lock.lock();
        try {
            if (!suspendedRoutes.contains(route)) {
                LOGGER.debug("Stopping consumer for {} ({})", route.getId(), route.getConsumer());
                stopConsumer(route.getConsumer());
                suspendedRoutes.add(route);
            }
        } catch (Exception e) {
            handleException(e);
        } finally {
            lock.unlock();
        }
    }

    public Properties createConsumerProperties() {
        Properties props = new Properties();
        addPropertyIfNotEmpty(props, ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, getKeyDeserializer());
        addPropertyIfNotEmpty(props, ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, getValueDeserializer());
        addPropertyIfNotEmpty(props, ConsumerConfig.FETCH_MIN_BYTES_CONFIG, getFetchMinBytes());
        addPropertyIfNotEmpty(props, ConsumerConfig.FETCH_MAX_BYTES_CONFIG, getFetchMaxBytes());
        addPropertyIfNotEmpty(props, ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG, getHeartbeatIntervalMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.MAX_PARTITION_FETCH_BYTES_CONFIG, getMaxPartitionFetchBytes());
        addPropertyIfNotEmpty(props, ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, getSessionTimeoutMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG, getMaxPollIntervalMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.MAX_POLL_RECORDS_CONFIG, getMaxPollRecords());
        addPropertyIfNotEmpty(props, ConsumerConfig.INTERCEPTOR_CLASSES_CONFIG, getInterceptorClasses());
        addPropertyIfNotEmpty(props, ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, getAutoOffsetReset());
        addPropertyIfNotEmpty(props, ConsumerConfig.CONNECTIONS_MAX_IDLE_MS_CONFIG, getConnectionMaxIdleMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, getAutoCommitEnable());
        addPropertyIfNotEmpty(props, ConsumerConfig.PARTITION_ASSIGNMENT_STRATEGY_CONFIG, getPartitionAssignor());
        addPropertyIfNotEmpty(props, ConsumerConfig.RECEIVE_BUFFER_CONFIG, getReceiveBufferBytes());
        addPropertyIfNotEmpty(props, ConsumerConfig.REQUEST_TIMEOUT_MS_CONFIG, getConsumerRequestTimeoutMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, getAutoCommitIntervalMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.CHECK_CRCS_CONFIG, getCheckCrcs());
        addPropertyIfNotEmpty(props, ConsumerConfig.CLIENT_ID_CONFIG, getClientId());
        addPropertyIfNotEmpty(props, ConsumerConfig.FETCH_MAX_WAIT_MS_CONFIG, getFetchWaitMaxMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.METADATA_MAX_AGE_CONFIG, getMetadataMaxAgeMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.METRIC_REPORTER_CLASSES_CONFIG, getMetricReporters());
        addPropertyIfNotEmpty(props, ConsumerConfig.METRICS_NUM_SAMPLES_CONFIG, getNoOfMetricsSample());
        addPropertyIfNotEmpty(props, ConsumerConfig.METRICS_SAMPLE_WINDOW_MS_CONFIG, getMetricsSampleWindowMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.RECONNECT_BACKOFF_MS_CONFIG, getReconnectBackoffMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.RETRY_BACKOFF_MS_CONFIG, getRetryBackoffMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.RETRY_BACKOFF_MAX_MS_CONFIG, getRetryBackoffMaxMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.RECONNECT_BACKOFF_MAX_MS_CONFIG, getReconnectBackoffMaxMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.ISOLATION_LEVEL_CONFIG, getIsolationLevel());
        addPropertyIfNotEmpty(props, "schema.registry.url", getSchemaRegistryURL());
        addPropertyIfNotFalse(props, "specific.avro.reader", isSpecificAvroReader());

         
        if (sslContextParameters != null) {
            applySslConfigurationFromContext(props, sslContextParameters);
        } else {
            applySslConsumerConfigurationFromOptions(props);
        }

         
        addPropertyIfNotEmpty(props, CommonClientConfigs.SECURITY_PROTOCOL_CONFIG, securityProtocol);

         
        if (isSasl(securityProtocol)) {
            applySaslConfiguration(props);
        }

         
        applyAdditionalProperties(props, getAdditionalProperties());

        return props;
    }

    private String determineBucketName(Exchange exchange) {
        String bucketName = exchange.getMessage().getHeader(GoogleCloudStorageConstants.OVERRIDE_BUCKET_NAME, String.class);
        if (ObjectHelper.isEmpty(bucketName)) {
            bucketName = getConfiguration().getBucketName();
        }
        if (bucketName == null) {
            throw new IllegalArgumentException("Bucket name is missing or not configured.");
        }
        return bucketName;
    }

    public Object getInstance(Message m) {
        Object result = null;
        if (provider != null) {
            result = provider.getInstance(m);
        } else {
             
            result = Proxy.newProxyInstance(clazz.getClassLoader(), new Class[] { clazz },
                    new SubResourceClassInvocationHandler());
        }
        return result;
    }

    public <T> Map<String, T> findByTypeWithName(Class<T> type) {
        Map<String, T> result = new HashMap<>();
         
        String keyPrefix = type.getName().replace('$', '/');
        kvClient = consul.keyValueClient();

        List<String> keys;
        try {
            keys = kvClient.getKeys(keyPrefix);
        } catch (ConsulException e) {
            return result;
        }

        if (keys != null) {
            Object obj;

            for (String key : keys) {
                 
                key = key.substring(key.lastIndexOf('/') + 1);
                obj = lookupByName(key.replace('$', '/'));
                if (type.isInstance(obj)) {
                    result.put(key, type.cast(obj));
                }
            }
        }
        return result;
    }

    public CreateIssueProducer(GitHubEndpoint endpoint) throws Exception {
        super(endpoint);

        Registry registry = endpoint.getCamelContext().getRegistry();
        Object service = registry.lookupByName(GitHubConstants.GITHUB_ISSUE_SERVICE);
        if (service != null) {
            issueService = (IssueService) service;
        } else {
            issueService = new IssueService();
        }
        initService(issueService);
    }

    private void tailLogFiles(Map<Long, Row> rows, int tail, Date limit) throws Exception {
        for (Row row : rows.values()) {
            Path log = logFile(row.pid);
            if (Files.exists(log)) {
                row.reader = new LineNumberReader(Files.newBufferedReader(log));
                String line;
                if (tail <= 0) {
                    row.fifo = new ArrayDeque<>();
                } else {
                    row.fifo = new ArrayBlockingQueue<>(tail);
                }
                do {
                    line = row.reader.readLine();
                    if (line != null) {
                        line = alignTimestamp(line);
                        boolean valid = isValidSince(limit, line);
                        if (valid && grep != null) {
                            valid = isValidGrep(line);
                        }
                        if (valid) {
                            while (!row.fifo.offer(line)) {
                                row.fifo.poll();
                            }
                        }
                    }
                } while (line != null);
            }
        }
    }

    public static String after(String text, String after) {
        if (text == null) {
            return null;
        }
        int pos = text.indexOf(after);
        if (pos == -1) {
            return null;
        }
        return text.substring(pos + after.length());
    }

    public List<String> getAllowableValuesAsStringList() {
        if (allowableValues == null) {
            return Collections.emptyList();
        } else {
            List<String> answer = new ArrayList<>();
            for (ValueDefinition v : allowableValues) {
                answer.add(v.getValue());
            }
            return answer;
        }
    }

    public Processor createProcessor() throws Exception {
        ObjectHelper.notNull(definition.getName(), "variableName");
        Expression expr = createExpression(definition.getExpression());
        Expression nameExpr;
        String key = parseString(definition.getName());
        if (LanguageSupport.hasSimpleFunction(key)) {
            nameExpr = camelContext.resolveLanguage("simple").createExpression(key);
        } else {
            nameExpr = camelContext.resolveLanguage("constant").createExpression(key);
        }
        nameExpr.init(camelContext);

        SetVariableProcessor answer = new SetVariableProcessor(nameExpr, expr);
        answer.setDisabled(isDisabled(camelContext, definition));
        return answer;
    }

    static Map<String, List<String>> determineHeaders(final Exchange exchange) {
        final Message inboundMessage = exchange.getIn();

        final Map<String, Object> headers = inboundMessage.getHeaders();

        final Map<String, List<String>> answer = new HashMap<>();
        for (final String headerName : headers.keySet()) {
            final String headerNameLowercase = headerName.toLowerCase(Locale.US);
            if (headerNameLowercase.startsWith("sforce") || headerNameLowercase.startsWith("x-sfdc")) {
                final Object headerValue = inboundMessage.getHeader(headerName);

                if (headerValue instanceof String) {
                    answer.put(headerName, Collections.singletonList((String) headerValue));
                } else if (headerValue instanceof String[]) {
                    answer.put(headerName, Arrays.asList((String[]) headerValue));
                } else if (headerValue instanceof Collection) {
                    answer.put(headerName,
                            ((Collection<?>) headerValue).stream().map(String::valueOf).collect(Collectors.<String> toList()));
                } else {
                    throw new IllegalArgumentException(
                            "Given value for header `" + headerName + "`, is not String, String array or a Collection");
                }
            }
        }
        return answer;
    }

        public void parse(String systemId) throws IOException, SAXException {
            lock.lock();
            try {
                checkValid();
                try {
                    xmlReader.parse(systemId);
                } finally {
                    release();
                }
            } finally {
                lock.unlock();
            }
        }

    private void synthesize(Exchange exchange) {
        TextToSpeech tts = getEndpoint().getTtsClient();
        if (tts == null) {
            throw new IllegalStateException("TTS client not initialized");
        }

        String text = exchange.getIn().getHeader(WatsonTextToSpeechConstants.TEXT, String.class);
        if (text == null) {
            text = exchange.getIn().getBody(String.class);
        }

        if (text == null || text.isBlank()) {
            throw new IllegalArgumentException("Text to synthesize must be specified");
        }

        String voice = exchange.getIn().getHeader(WatsonTextToSpeechConstants.VOICE,
                getEndpoint().getConfiguration().getVoice(), String.class);
        String accept = exchange.getIn().getHeader(WatsonTextToSpeechConstants.ACCEPT,
                getEndpoint().getConfiguration().getAccept(), String.class);
        String customizationId = exchange.getIn().getHeader(WatsonTextToSpeechConstants.CUSTOMIZATION_ID,
                getEndpoint().getConfiguration().getCustomizationId(), String.class);

        LOG.trace("Synthesizing text with TTS: voice={}, accept={}", voice, accept);

        SynthesizeOptions.Builder builder = new SynthesizeOptions.Builder()
                .text(text)
                .voice(voice)
                .accept(accept);

        if (customizationId != null && !customizationId.isBlank()) {
            builder.customizationId(customizationId);
        }

        SynthesizeOptions options = builder.build();

        InputStream audioStream = tts.synthesize(options).execute().getResult();

        Message message = getMessageForResponse(exchange);
        message.setBody(audioStream);
        message.setHeader(WatsonTextToSpeechConstants.VOICE, voice);
        message.setHeader(WatsonTextToSpeechConstants.ACCEPT, accept);
    }

    protected static String jkubeMavenPluginVersion(Path settings, Properties props) {
        String answer = null;
        if (props != null) {
            answer = props.getProperty(JKUBE_MAVEN_PLUGIN_VERSION);
        }
        if (answer == null) {
            try {
                List<String> lines = RuntimeUtil.loadPropertiesLines(settings);
                answer = lines.stream()
                        .filter(l -> l.startsWith(JKUBE_MAVEN_PLUGIN_VERSION + "=") || l.startsWith("jkube.version="))
                        .map(s -> StringHelper.after(s, "=")).findFirst().orElse(null);
            } catch (Exception e) {
                 
            }
        }
        return answer != null ? answer : "1.18.1";
    }

    protected void doStart() throws Exception {
        ObjectHelper.notNull(camelContext, "camelContext");
        ObjectHelper.notNull(configuration, "configuration");

        if (cache != null) {
            cacheManager = new JCacheManager<>(cache);
        } else {
            cacheManager = JCacheHelper.createManager(getCamelContext(), configuration);
            cache = cacheManager.getCache();
        }
    }

    public Integer doProcessWatchCall() throws Exception {
        List<Row> rows = new ArrayList<>();

        List<Long> pids = findPids(name);
        ProcessHandle.allProcesses()
                .filter(ph -> pids.contains(ph.pid()))
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                     
                    if (root != null) {
                        Row row = new Row();
                        JsonObject context = (JsonObject) root.get("context");
                        if (context == null) {
                            return;
                        }
                        row.name = context.getString("name");
                        if ("CamelJBang".equals(row.name)) {
                            row.name = ProcessHelper.extractName(root, ph);
                        }
                        row.pid = Long.toString(ph.pid());
                        row.uptime = extractSince(ph);
                        row.age = TimeUtils.printSince(row.uptime);

                        JsonObject jo = (JsonObject) root.get("services");
                        if (jo != null) {
                            JsonArray arr = (JsonArray) jo.get("services");
                            if (arr != null) {
                                for (int i = 0; i < arr.size(); i++) {
                                    row = row.copy();
                                    jo = (JsonObject) arr.get(i);
                                    row.component = jo.getString("component");
                                    row.direction = jo.getString("direction");
                                    row.hosted = jo.getBooleanOrDefault("hosted", false);
                                    row.protocol = jo.getString("protocol");
                                    row.serviceUrl = jo.getString("serviceUrl");
                                    row.endpointUri = jo.getString("endpointUri");
                                    row.hits = jo.getLongOrDefault("hits", 0);
                                    row.routeId = jo.getString("routeId");
                                    row.metadata = jo.getMap("metadata");
                                    rows.add(row);
                                }
                            }
                        }
                    }
                });

         
        rows.sort(this::sortRow);

        if (!rows.isEmpty()) {
            printer().println(AsciiTable.getTable(AsciiTable.NO_BORDERS, rows, Arrays.asList(
                    new Column().header("PID").headerAlign(HorizontalAlign.CENTER).with(r -> r.pid),
                    new Column().header("NAME").dataAlign(HorizontalAlign.LEFT).maxWidth(30, OverflowBehaviour.ELLIPSIS_RIGHT)
                            .with(r -> r.name),
                    new Column().header("COMPONENT").dataAlign(HorizontalAlign.LEFT).with(r -> r.component),
                    new Column().header("DIR").dataAlign(HorizontalAlign.LEFT).with(r -> r.direction),
                    new Column().header("ROUTE").dataAlign(HorizontalAlign.LEFT).with(this::getRouteId),
                    new Column().header("PROTOCOL").dataAlign(HorizontalAlign.LEFT).with(this::getProtocol),
                    new Column().header("SERVICE").dataAlign(HorizontalAlign.LEFT).with(this::getService),
                    new Column().header("METADATA").visible(metadata).dataAlign(HorizontalAlign.LEFT).with(this::getMetadata),
                    new Column().header("TOTAL").dataAlign(HorizontalAlign.RIGHT).with(r -> "" + r.hits),
                    new Column().header("ENDPOINT").visible(!wideUri).dataAlign(HorizontalAlign.LEFT)
                            .maxWidth(90, OverflowBehaviour.ELLIPSIS_RIGHT)
                            .with(this::getUri),
                    new Column().header("ENDPOINT").visible(wideUri).dataAlign(HorizontalAlign.LEFT)
                            .maxWidth(140, OverflowBehaviour.NEWLINE)
                            .with(this::getUri))));
        }

        return 0;
    }

    private String getId(SuspendedRow r) {
        if (r.first) {
            return "*-->";
        } else if (r.last) {
            return "*<--";
        } else {
            return r.nodeId;
        }
    }

        void add(FileInputStreamCache fileInputStreamCache) {
            lock.lock();
            try {
                if (fileInputStreamCaches == null) {
                    fileInputStreamCaches = new ArrayList<>(3);
                }
                fileInputStreamCaches.add(fileInputStreamCache);
            } finally {
                lock.unlock();
            }
        }

    private void closeQuietly(ResultSet rs) {
        if (rs != null) {
            try {
                if (!rs.isClosed()) {
                    rs.close();
                }
            } catch (Exception sqle) {
                LOG.debug("Error by closing result set", sqle);
            }
        }
    }

    public void releaseExclusiveReadLockOnRollback(
            GenericFileOperations<File> operations, GenericFile<File> file, Exchange exchange)
            throws Exception {
        String key = asKey(exchange, file);
        if (removeOnRollback) {
            idempotentRepository.remove(exchange, key);
        } else {
             
            idempotentRepository.confirm(exchange, key);
        }

        rename.releaseExclusiveReadLockOnRollback(operations, file, exchange);
    }

    protected static List<String> getParameters(String path) {
        List<String> parameters = null;

        int startIndex = path.indexOf('{');
        while (startIndex != -1) {
            int endIndex = path.indexOf('}', startIndex);
            if (endIndex != -1) {
                if (parameters == null) {
                    parameters = new ArrayList<>();
                }
                parameters.add(path.substring(startIndex + 1, endIndex));
                startIndex = path.indexOf('{', endIndex);
            } else {
                 
                startIndex = -1;
            }
        }

        return parameters == null ? Collections.emptyList() : parameters;
    }

    private static boolean isAnalyticsOperation(OperationName operationName) {
        switch (operationName) {
            case GET_RECENT_REPORTS:
            case GET_REPORT_DESCRIPTION:
            case EXECUTE_SYNCREPORT:
            case EXECUTE_ASYNCREPORT:
            case GET_REPORT_INSTANCES:
            case GET_REPORT_RESULTS:
                return true;
            default:
                return false;
        }
    }

    public GenericFileProcessStrategy<FileIdBothDirectoryInformation> createGenericFileProcessStrategy(
            CamelContext context, Map<String, Object> params) {

         
         
        Expression moveExpression = (Expression) params.get("move");
        Expression moveFailedExpression = (Expression) params.get("moveFailed");
        Expression preMoveExpression = (Expression) params.get("preMove");
        boolean isNoop = params.get("noop") != null;
        boolean isDelete = params.get("delete") != null;
        boolean isMove = moveExpression != null || preMoveExpression != null || moveFailedExpression != null;

        if (isDelete) {
            GenericFileDeleteProcessStrategy<FileIdBothDirectoryInformation> strategy
                    = new GenericFileDeleteProcessStrategy<>();
            strategy.setExclusiveReadLockStrategy(getExclusiveReadLockStrategy(params));
            if (preMoveExpression != null) {
                GenericFileExpressionRenamer<FileIdBothDirectoryInformation> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(preMoveExpression);
                strategy.setBeginRenamer(renamer);
            }
            if (moveFailedExpression != null) {
                GenericFileExpressionRenamer<FileIdBothDirectoryInformation> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(moveFailedExpression);
                strategy.setFailureRenamer(renamer);
            }
            return strategy;
        } else if (isMove || isNoop) {
            GenericFileRenameProcessStrategy<FileIdBothDirectoryInformation> strategy
                    = new GenericFileRenameProcessStrategy<>();
            strategy.setExclusiveReadLockStrategy(getExclusiveReadLockStrategy(params));
            if (!isNoop && moveExpression != null) {
                 
                GenericFileExpressionRenamer<FileIdBothDirectoryInformation> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(moveExpression);
                strategy.setCommitRenamer(renamer);
            }
             
            if (moveFailedExpression != null) {
                GenericFileExpressionRenamer<FileIdBothDirectoryInformation> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(moveFailedExpression);
                strategy.setFailureRenamer(renamer);
            }
             
            if (preMoveExpression != null) {
                GenericFileExpressionRenamer<FileIdBothDirectoryInformation> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(preMoveExpression);
                strategy.setBeginRenamer(renamer);
            }
            return strategy;
        } else {
             
            GenericFileNoOpProcessStrategy<FileIdBothDirectoryInformation> strategy = new GenericFileNoOpProcessStrategy<>();
            strategy.setExclusiveReadLockStrategy(getExclusiveReadLockStrategy(params));
            return strategy;
        }
    }

    protected void doList(Exchange exchange) {
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        JobList jobList;

        if (ObjectHelper.isEmpty(namespace)) {
            jobList = getEndpoint().getKubernetesClient().batch().v1().jobs().inAnyNamespace().list();
        } else {
            jobList = getEndpoint().getKubernetesClient().batch().v1().jobs().inNamespace(namespace).list();
        }

        prepareOutboundMessage(exchange, jobList.getItems());
    }

    private void processCloseJob(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {
        JobInfo jobBody;
        String jobId;
        jobBody = exchange.getIn().getBody(JobInfo.class);
        if (jobBody != null) {
            jobId = jobBody.getId();
        } else {
            jobId = getParameter(JOB_ID, exchange, USE_BODY, NOT_OPTIONAL);
        }
        bulkClient.closeJob(jobId, determineHeaders(exchange), new BulkApiClient.JobInfoResponseCallback() {
            @Override
            public void onResponse(JobInfo jobInfo, Map<String, String> headers, SalesforceException ex) {
                processResponse(exchange, jobInfo, headers, ex, callback);
            }
        });
    }

    public void process(Exchange exchange) {
        if (exchange.getIn().getBody() instanceof String) {
            String input = exchange.getIn().getBody(String.class);
            T result = predict(exchange, input);
            exchange.getIn().setBody(result);
        } else {
            throw new RuntimeCamelException("Data type is not supported. Body should be String");
        }
    }

    protected boolean pollDirectory(Exchange dynamic, String fileName, List<GenericFile<FTPFile>> fileList, int depth) {
        String currentDir = null;
        if (isStepwise()) {
             
             
            currentDir = operations.getCurrentDirectory();
        }

         
        fileName = FileUtil.stripTrailingSeparator(fileName);

        boolean answer = doPollDirectory(dynamic, fileName, null, fileList, depth);
        if (currentDir != null) {
            operations.changeCurrentDirectory(currentDir);
        }

        return answer;
    }

    public String extractText(String chunk) throws JsonProcessingException {
        if (chunk == null || chunk.trim().isEmpty()) {
            return "";
        }
        JsonNode node = MAPPER.readTree(chunk);
        JsonNode eventType = node.get("event_type");

        if (eventType != null && "text-generation".equals(eventType.asText())) {
            JsonNode text = node.get("text");
            return text != null && !text.isNull() ? text.asText() : "";
        }
        return "";
    }

    public Calendar makeClient(
            CamelContext camelContext, String serviceAccountKey, Collection<String> scopes, String applicationName,
            String delegate) {
        if (serviceAccountKey == null) {
            throw new IllegalArgumentException("serviceAccountKey is required to create Google Calendar client.");
        }
        try {
            Credential credential = authorizeServiceAccount(camelContext, serviceAccountKey, delegate, scopes);
            return new Calendar.Builder(transport, jsonFactory, credential).setApplicationName(applicationName).build();
        } catch (Exception e) {
            throw new RuntimeCamelException("Could not create Google Calendar client.", e);
        }
    }

    private void updateFunction(CloudFunctionsServiceClient client, Exchange exchange)
            throws InvalidPayloadException, InterruptedException, ExecutionException {
        CloudFunction response = null;
        if (getConfiguration().isPojoRequest()) {
            UpdateFunctionRequest request = exchange.getIn().getMandatoryBody(UpdateFunctionRequest.class);
            response = client.updateFunctionAsync(request).get();
        } else {
            throw new IllegalArgumentException("updateFunction is supported only in pojo mode");
        }
        Message message = getMessageForResponse(exchange);
        message.setBody(response);
    }

    private SslHandler configureServerSSLOnDemand() {
        if (!consumer.getConfiguration().isSsl()) {
            return null;
        }

        if (consumer.getConfiguration().getSslHandler() != null) {
            return consumer.getConfiguration().getSslHandler();
        } else if (sslContext != null) {
            SSLEngine engine = sslContext.createSSLEngine();
            engine.setUseClientMode(false);
            engine.setNeedClientAuth(consumer.getConfiguration().isNeedClientAuth());
            if (consumer.getConfiguration().isHostnameVerification()) {
                SSLParameters sslParams = engine.getSSLParameters();
                sslParams.setEndpointIdentificationAlgorithm("HTTPS");
                engine.setSSLParameters(sslParams);
            }
            if (consumer.getConfiguration().getSslContextParameters() == null) {
                 
                engine.setEnabledProtocols(consumer.getConfiguration().getEnabledProtocols().split(","));
            }
            return new SslHandler(engine);
        }

        return null;
    }

    protected void doStop() throws Exception {
        if (listenerContainer != null) {

            if (getEndpoint().getConfiguration().isAsyncStopListener()) {
                getEndpoint().getAsyncStartStopExecutorService().submit(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            stopAndDestroyListenerContainer();
                        } catch (Exception e) {
                            LOG.warn("Error stopping listener container on destination: {}. This exception will be ignored.",
                                    getDestinationName(), e);
                        }
                    }

                    @Override
                    public String toString() {
                        return "AsyncStopListenerTask[" + getDestinationName() + "]";
                    }
                });
            } else {
                stopAndDestroyListenerContainer();
            }
        }

        super.doStop();
    }

    public Object unmarshal(final Exchange exchange, final InputStream inputStream) throws Exception {
        if (usingIterator) {
            ZipIterator zipIterator = new ZipIterator(exchange, inputStream);
            zipIterator.setAllowEmptyDirectory(allowEmptyDirectory);
            return zipIterator;
        } else {
            BufferedInputStream bis = new BufferedInputStream(inputStream);
            ZipArchiveInputStream zis = new ArchiveStreamFactory()
                    .createArchiveInputStream(ArchiveStreamFactory.ZIP, bis);
            OutputStreamBuilder osb = OutputStreamBuilder.withExchange(exchange);

            try {
                ZipArchiveEntry entry = zis.getNextEntry();
                if (entry != null) {
                    exchange.getMessage().setHeader(FILE_NAME, entry.getName());
                    IOHelper.copy(zis, osb, IOHelper.DEFAULT_BUFFER_SIZE, false, maxDecompressedSize);
                } else {
                    throw new IllegalStateException("Unable to unzip the file, it may be corrupted.");
                }

                entry = zis.getNextEntry();
                if (entry != null) {
                    throw new IllegalStateException("Zip file has more than 1 entry.");
                }

                return osb.build();
            } finally {
                IOHelper.close(osb, zis, bis);
            }
        }
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.util.List.class, org.dizitart.no2.Cursor.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.nitrite.NitriteTypeConverters.fromCursorToList((org.dizitart.no2.Cursor) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.dizitart.no2.Document.class, java.util.Map.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.nitrite.NitriteTypeConverters.fromMapToDocument((java.util.Map) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    public Map<String, Object> endpointProperties(Exchange exchange, String uri) throws Exception {
        Map<String, Object> properties;
         
        Map<String, Object> map = URISupport.parseQuery(URISupport.extractQuery(uri));
        if (map != null && !map.isEmpty() && isLenientProperties()) {
            if (resolveRawParameterValues()) {
                 
                 
                 
                RawParameterHelper.resolveRawParameterValues(exchange.getContext(), map);
            }
             
            properties = new LinkedHashMap<>();
            map.forEach((k, v) -> {
                boolean accept = knownProperties.contains(k);
                 
                 
                if (!accept && !knownPrefixes.isEmpty()) {
                    accept = knownPrefixes.values().stream().anyMatch(k::startsWith);
                }
                if (accept) {
                    properties.put(k, v);
                }
            });
        } else {
            properties = map;
        }

        return properties;
    }

    public void index(Object result) {
        if (result instanceof ODataFeed) {
            index((ODataFeed) result);
        } else if (result instanceof Iterable) {
            index((Iterable<?>) result);
        } else if (result instanceof ODataEntry) {
            index((ODataEntry) result);
        } else {
            indexDefault(result);
        }
    }

    public static Expression nullExpression() {
        return new ExpressionAdapter() {
            @Override
            public Object evaluate(Exchange exchange) {
                return null;
            }

            @Override
            public String toString() {
                return "null";
            }
        };
    }

    public static EventHubProducerAsyncClient createEventHubProducerAsyncClient(final EventHubsConfiguration configuration) {
        EventHubClientBuilder eventHubClientBuilder = new EventHubClientBuilder()
                .transportType(configuration.getAmqpTransportType())
                .retryOptions(configuration.getAmqpRetryOptions());

        CredentialType type = configuration.getCredentialType();
        if (type == null) {
            type = CredentialType.CONNECTION_STRING;
        }
        if (CredentialType.CONNECTION_STRING.equals(type)) {
            return eventHubClientBuilder
                    .connectionString(buildConnectionString(configuration))
                    .buildAsyncProducerClient();
        } else if (CredentialType.TOKEN_CREDENTIAL.equals(type)) {

            checkTokenCredentialConfiguration(configuration);
            return eventHubClientBuilder
                    .fullyQualifiedNamespace(getFullyQualifiedNamespace(configuration))
                    .eventHubName(configuration.getEventHubName())
                    .credential(configuration.getTokenCredential())
                    .buildAsyncProducerClient();
        }
        return eventHubClientBuilder
                .fullyQualifiedNamespace(getFullyQualifiedNamespace(configuration))
                .eventHubName(configuration.getEventHubName())
                .credential(new DefaultAzureCredentialBuilder().build())
                .buildAsyncProducerClient();
    }

    private boolean updateOptionsIn(final File file, final String kind, final String changed) throws MojoExecutionException {
        if (!file.exists()) {
            return false;
        }

        final String updated = changed.trim();
        try {
            String text = PackageHelper.loadText(file);

            String existing = Strings.between(text, "// " + kind + " options: START", "// " + kind + " options: END");
            if (existing != null) {
                 
                existing = existing.trim();
                if (existing.equals(updated)) {
                    return false;
                }

                String before = Strings.before(text, "// " + kind + " options: START");
                String after = Strings.after(text, "// " + kind + " options: END");
                text = before + "// " + kind + " options: START\n" + updated + "\n// " + kind + " options: END" + after;
                PackageHelper.writeText(file, text);
                return true;
            }

            getLog().warn("Cannot find markers in file " + file);
            getLog().warn("Add the following markers");
            getLog().warn("\t// " + kind + " options: START");
            getLog().warn("\t// " + kind + " options: END");
            return false;
        } catch (IOException e) {
            throw new MojoExecutionException("Error reading file " + file + " Reason: " + e, e);
        }
    }

    public static String resolveQuery(CamelContext camelContext, String query, String placeholder)
            throws NoTypeConversionAvailableException, IOException {
        String answer = query;
        if (ResourceHelper.hasScheme(query)) {
            try (InputStream is = ResourceHelper.resolveMandatoryResourceAsInputStream(camelContext, query)) {
                answer = camelContext.getTypeConverter().mandatoryConvertTo(String.class, is);
                if (placeholder != null) {
                    answer = answer.replaceAll(placeholder, "@");
                }
            }
        }
        return answer;
    }

    public DocFlavor forMimeTypePOSTSCRIPT(String flavor) {
        if (flavor.equalsIgnoreCase("DocFlavor.BYTE_ARRAY")) {
            d = DocFlavor.BYTE_ARRAY.POSTSCRIPT;
        } else if (flavor.equalsIgnoreCase("DocFlavor.INPUT_STREAM")) {
            d = DocFlavor.INPUT_STREAM.POSTSCRIPT;
        } else if (flavor.equalsIgnoreCase("DocFlavor.URL")) {
            d = DocFlavor.URL.POSTSCRIPT;
        }

        return d;
    }

    void onResult(String connectionKey) {
        lock.lock();
        try {
            connectionKeys.remove(connectionKey);
            if (connectionKeys.isEmpty()) {
                onComplete();
            }
        } finally {
            lock.unlock();
        }
    }

    public KeyPair rotateKey(String oldKeyId, String newKeyId, String algorithm) throws Exception {
        LOG.info("Rotating key from {} to {}", oldKeyId, newKeyId);

         
        KeyMetadata oldMetadata = getKeyMetadata(oldKeyId);
        if (oldMetadata == null) {
            throw new IllegalArgumentException("Old key not found: " + oldKeyId);
        }

         
        oldMetadata.setStatus(KeyMetadata.KeyStatus.DEPRECATED);
        updateKeyMetadata(oldKeyId, oldMetadata);

         
        KeyPair newKeyPair = generateKeyPair(algorithm, newKeyId);

        LOG.info("Key rotation completed in AWS Secrets Manager: {} -> {}", oldKeyId, newKeyId);
        return newKeyPair;
    }

    private int doRunDebugSpringBoot(KameletMain main) throws Exception {
        Path pom = Paths.get("pom.xml");
        MavenXpp3Reader mavenReader = new MavenXpp3Reader();
        try (Reader reader = Files.newBufferedReader(pom)) {
            Model model = mavenReader.read(reader);

             
            Dependency d = new Dependency();
            d.setGroupId("org.apache.camel.springboot");
            d.setArtifactId("camel-debug-starter");
            model.getDependencies().add(d);
            d = new Dependency();
            d.setGroupId("org.apache.camel.springboot");
            d.setArtifactId("camel-cli-connector-starter");
            model.getDependencies().add(d);

            Profile mp = new Profile();
            model.addProfile(mp);
            mp.setId("camel-debug");
            Activation a = new Activation();
            a.setActiveByDefault(true);
            mp.setActivation(a);

            Build b = new Build();
            mp.setBuild(b);

            Plugin pi = new Plugin();
            b.addPlugin(pi);
            pi.setGroupId("org.springframework.boot");
            pi.setArtifactId("spring-boot-maven-plugin");
            pi.setVersion("${spring-boot-version}");
            PluginExecution pe = new PluginExecution();
            pe.addGoal("repackage");
            pi.addExecution(pe);
            Xpp3Dom cfg = new Xpp3Dom("finalName");
            cfg.setValue("camel-jbang-debug");
            Xpp3Dom root = new Xpp3Dom("configuration");
            root.addChild(cfg);
            pi.setConfiguration(root);

            MavenXpp3Writer w = new MavenXpp3Writer();
            FileOutputStream fos = new FileOutputStream("camel-jbang-debug-pom.xml", false);
            w.write(fos, model);
            IOHelper.close(fos);

            printer().println("Preparing Camel Spring Boot for debugging ...");

             
            String mvnw = "/mvnw";
            if (FileUtil.isWindows()) {
                mvnw = "/mvnw.cmd";
            }
            if (!new File(mvnw).exists()) {
                mvnw = "mvn";
            }
             
            ProcessBuilder pb = new ProcessBuilder();
            pb.command(mvnw, "-Dmaven.test.skip", "--file", "camel-jbang-debug-pom.xml", "package", "spring-boot:repackage");
            Process p = pb.start();

            if (p.waitFor(30, TimeUnit.SECONDS)) {
                AtomicReference<Process> processRef = new AtomicReference<>();
                Runtime.getRuntime().addShutdownHook(new Thread(() -> {
                    try {
                         
                        Process process = processRef.get();
                        if (process != null) {
                            process.destroy();
                            for (int i = 0; i < 30; i++) {
                                if (!process.isAlive()) {
                                    break;
                                }
                                try {
                                    Thread.sleep(1000);
                                } catch (InterruptedException e) {
                                    Thread.currentThread().interrupt();
                                }
                            }
                        }
                        removeDir(Paths.get(RUN_PLATFORM_DIR));
                        removeDir(Paths.get(CAMEL_JBANG_WORK_DIR));
                        Files.deleteIfExists(Paths.get("camel-jbang-debug-pom.xml"));
                    } catch (Exception e) {
                         
                    }
                }));

                 
                pb = new ProcessBuilder();
                pb.command("java",
                        "-Dcamel.debug.enabled=true",
                        (breakpoint == null
                                ? "-Dcamel.debug.breakpoints=_all_routes_" : "-Dcamel.debug.breakpoints=" + breakpoint),
                        "-Dcamel.debug.loggingLevel=DEBUG",
                        "-Dcamel.debug.singleStepIncludeStartEnd=true",
                        loggingColor ? "-Dspring.output.ansi.enabled=ALWAYS" : "-Dspring.output.ansi.enabled=NEVER",
                        "-jar", "target/camel-jbang-debug.jar");

                p = pb.start();
                processRef.set(p);
                this.spawnOutput = p.getInputStream();
                this.spawnError = p.getErrorStream();
                this.spawnPid = p.pid();
                printer().println("Debugging Camel Spring Boot integration: " + name + " with PID: " + p.pid());
            } else {
                printer().printErr("Timed out preparing Camel Spring Boot for debugging");
                this.spawnError = p.getErrorStream();
                this.spawnPid = p.pid();
                p.destroy();
                return -1;
            }
        }

        return 0;
    }

    public void pre(Entity segment, Exchange exchange, Endpoint endpoint) {
        super.pre(segment, exchange, endpoint);

        String partition = (String) exchange.getIn().getHeader(PARTITION);
        if (partition != null) {
            segment.putMetadata(KAFKA_PARTITION_TAG, partition);
        }

        String partitionKey = (String) exchange.getIn().getHeader(PARTITION_KEY);
        if (partitionKey != null) {
            segment.putMetadata(KAFKA_PARTITION_KEY_TAG, partitionKey);
        }

        String key = (String) exchange.getIn().getHeader(KEY);
        if (key != null) {
            segment.putMetadata(KAFKA_KEY_TAG, key);
        }

        String offset = (String) exchange.getIn().getHeader(OFFSET);
        if (offset != null) {
            segment.putMetadata(KAFKA_OFFSET_TAG, offset);
        }
    }

    protected void doInit() throws Exception {
        if (metricsRegistry == null) {
            Registry camelRegistry = getCamelContext().getRegistry();
            metricsRegistry = camelRegistry.lookupByNameAndType(MetricsComponent.METRIC_REGISTRY_NAME, MetricRegistry.class);
             
            if (metricsRegistry == null) {
                metricsRegistry = new MetricRegistry();
            }
        }

         
        this.mapper = new ObjectMapper().registerModule(new MetricsModule(getRateUnit(), getDurationUnit(), false));
        if (getRateUnit() == TimeUnit.SECONDS && getDurationUnit() == TimeUnit.SECONDS) {
             
            this.secondsMapper = this.mapper;
        } else {
            this.secondsMapper
                    = new ObjectMapper().registerModule(new MetricsModule(TimeUnit.SECONDS, TimeUnit.SECONDS, false));
        }
    }

  final public Token InParameterSrc() throws ParseException {Token ret = null;
    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
    case SIMPLE_EXP_TOKEN:{
      ret = jj_consume_token(SIMPLE_EXP_TOKEN);
{if ("" != null) return ret;}
      break;
      }
    case PARAMETER_POS_TOKEN:{
      ret = jj_consume_token(PARAMETER_POS_TOKEN);
{if ("" != null) return ret;}
      break;
      }
    default:
      jj_la1[11] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
}

    public String chat(AiAgentBody<?> aiAgentBody, ToolProvider toolProvider) {
        AiAgentWithoutMemoryService agentService = createAiAgentService(toolProvider);

        String userMessage = aiAgentBody.getUserMessage();
        String systemMessage = aiAgentBody.getSystemMessage();
        Content content = aiAgentBody.getContent();

        if (content != null) {
             
            return systemMessage != null
                    ? agentService.chat(userMessage, content, systemMessage)
                    : agentService.chat(userMessage, content);
        } else {
             
            return systemMessage != null
                    ? agentService.chat(userMessage, systemMessage)
                    : agentService.chat(userMessage);
        }
    }

    protected void doList(Exchange exchange) {
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        ReplicationControllerList rcList;
        if (ObjectHelper.isEmpty(namespace)) {
            rcList = getEndpoint().getKubernetesClient().replicationControllers().inAnyNamespace().list();
        } else {
            rcList = getEndpoint().getKubernetesClient().replicationControllers().inNamespace(namespace).list();
        }

        prepareOutboundMessage(exchange, rcList.getItems());
    }

    private void updateResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String permissionId = exchange.getIn().getHeader(KeycloakConstants.PERMISSION_ID, String.class);
        if (ObjectHelper.isEmpty(permissionId)) {
            throw new IllegalArgumentException("Permission ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                 
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(permissionId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Permission updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update permission requires POJO request with PolicyRepresentation");
        }
    }

    public GenericFileProcessStrategy<FTPFile> createGenericFileProcessStrategy(
            CamelContext context, Map<String, Object> params) {

         
         
        Expression moveExpression = (Expression) params.get("move");
        Expression moveFailedExpression = (Expression) params.get("moveFailed");
        Expression preMoveExpression = (Expression) params.get("preMove");
        boolean isNoop = params.get("noop") != null;
        boolean isDelete = params.get("delete") != null;
        boolean isMove = moveExpression != null || preMoveExpression != null || moveFailedExpression != null;

        if (isDelete) {
            GenericFileDeleteProcessStrategy<FTPFile> strategy = new GenericFileDeleteProcessStrategy<>();
            strategy.setExclusiveReadLockStrategy(getExclusiveReadLockStrategy(params));
            if (preMoveExpression != null) {
                GenericFileExpressionRenamer<FTPFile> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(preMoveExpression);
                strategy.setBeginRenamer(renamer);
            }
            if (moveFailedExpression != null) {
                GenericFileExpressionRenamer<FTPFile> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(moveFailedExpression);
                strategy.setFailureRenamer(renamer);
            }
            return strategy;
        } else if (isMove || isNoop) {
            GenericFileRenameProcessStrategy<FTPFile> strategy = new GenericFileRenameProcessStrategy<>();
            strategy.setExclusiveReadLockStrategy(getExclusiveReadLockStrategy(params));
            if (!isNoop && moveExpression != null) {
                 
                GenericFileExpressionRenamer<FTPFile> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(moveExpression);
                strategy.setCommitRenamer(renamer);
            }
             
            if (moveFailedExpression != null) {
                GenericFileExpressionRenamer<FTPFile> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(moveFailedExpression);
                strategy.setFailureRenamer(renamer);
            }
             
            if (preMoveExpression != null) {
                GenericFileExpressionRenamer<FTPFile> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(preMoveExpression);
                strategy.setBeginRenamer(renamer);
            }
            return strategy;
        } else {
             
            GenericFileNoOpProcessStrategy<FTPFile> strategy = new GenericFileNoOpProcessStrategy<>();
            strategy.setExclusiveReadLockStrategy(getExclusiveReadLockStrategy(params));
            return strategy;
        }
    }

    private void delayOrScheduleLockRelease(Runnable r) throws InterruptedException {
        if (readLockIdempotentReleaseDelay > 0 && readLockIdempotentReleaseExecutorService != null) {
            LOG.debug("Scheduling read lock release task to run asynchronous delayed after {} millis",
                    readLockIdempotentReleaseDelay);
            readLockIdempotentReleaseExecutorService.schedule(r, readLockIdempotentReleaseDelay, TimeUnit.MILLISECONDS);
        } else if (readLockIdempotentReleaseDelay > 0) {
            LOG.debug("Delaying read lock release task {} millis", readLockIdempotentReleaseDelay);
            Thread.sleep(readLockIdempotentReleaseDelay);
            r.run();
        } else {
            r.run();
        }
    }

    public int processBatch(Queue<Object> exchanges) throws Exception {
        int total = exchanges.size();
        int answer = total;
        if (this.maxMessagesPerPoll > 0 && total > this.maxMessagesPerPoll) {
            LOG.debug("Limiting to maximum messages to poll {} as there were {} messages in this poll.",
                    this.maxMessagesPerPoll, total);
            total = this.maxMessagesPerPoll;
        }

        for (int index = 0; index < total && this.isBatchAllowed(); ++index) {
            Exchange exchange = (Exchange) exchanges.poll();
            exchange.setProperty(ExchangePropertyKey.BATCH_INDEX, index);
            exchange.setProperty(ExchangePropertyKey.BATCH_SIZE, total);
            exchange.setProperty(ExchangePropertyKey.BATCH_COMPLETE, index == total - 1);
            this.pendingExchanges = total - index - 1;
            Object value = onPreProcessed(exchange);
            getProcessor().process(exchange);
            onProcessed(exchange, value);
        }

        return answer;
    }

    protected boolean doRun(BooleanSupplier supplier) {
        try {
            cause = null;
            return supplier.getAsBoolean();
        } catch (TaskRunFailureException e) {
            LOG.debug("Task {} failed at {} iterations and will attempt again on next interval: {}",
                    getName(), budget.iteration(), e.getMessage());
            cause = e;
            return false;
        }
    }

    public String apply(String remainder) {
        String key = remainder;
        String subkey = null;
        String returnValue = null;
        String defaultValue = null;
        String version = null;

        if (remainder.contains("#")) {
            key = StringHelper.before(remainder, "#");
            subkey = StringHelper.after(remainder, "#");
            defaultValue = StringHelper.after(subkey, ":");
            if (ObjectHelper.isNotEmpty(defaultValue)) {
                if (defaultValue.contains("@")) {
                    version = StringHelper.after(defaultValue, "@");
                    defaultValue = StringHelper.before(defaultValue, "@");
                }
            }
            if (subkey.contains(":")) {
                subkey = StringHelper.before(subkey, ":");
            }
            if (subkey.contains("@")) {
                version = StringHelper.after(subkey, "@");
                subkey = StringHelper.before(subkey, "@");
            }
        } else if (remainder.contains(":")) {
            key = StringHelper.before(remainder, ":");
            defaultValue = StringHelper.after(remainder, ":");
            if (remainder.contains("@")) {
                version = StringHelper.after(remainder, "@");
                defaultValue = StringHelper.before(defaultValue, "@");
            }
        } else {
            if (remainder.contains("@")) {
                key = StringHelper.before(remainder, "@");
                version = StringHelper.after(remainder, "@");
            }
        }

        if (key != null) {
            try {
                returnValue = getSecretFromSource(key, subkey, defaultValue, version);
            } catch (Exception e) {
                throw new RuntimeCamelException(
                        "Error getting secret from CyberArk Conjur vault using key: " + key + " due to: " + e.getMessage(),
                        e);
            }
        }

        return returnValue;
    }

    public String toString() {
        StringBuilder builder = new StringBuilder();
        if (trustManager != null) {
            builder.append("TrustManagerType[trustManager=");
            builder.append(trustManager);
            builder.append("]");
        } else {
            builder.append("TrustManagerType[keyStore=");
            builder.append(keyStore);
            builder.append(", provider=");
            builder.append(provider);
            builder.append(", algorithm=");
            builder.append(algorithm);
            builder.append("]");
        }
        return builder.toString();
    }

    private void processConverseStreamingRequest(ConverseStreamRequest request, Exchange exchange) {
        try {
            String streamOutputMode = getConfiguration().getStreamOutputMode();
            if (streamOutputMode == null) {
                streamOutputMode = "complete";
            }

             
            if (ObjectHelper.isNotEmpty(exchange.getMessage().getHeader(BedrockConstants.STREAM_OUTPUT_MODE))) {
                streamOutputMode = exchange.getIn().getHeader(BedrockConstants.STREAM_OUTPUT_MODE, String.class);
            }

            org.apache.camel.Message message = getMessageForResponse(exchange);
            org.apache.camel.component.aws2.bedrock.runtime.stream.ConverseStreamHandler.StreamMetadata metadata
                    = new org.apache.camel.component.aws2.bedrock.runtime.stream.ConverseStreamHandler.StreamMetadata();

            if ("chunks".equals(streamOutputMode)) {
                 
                List<String> allChunks = new ArrayList<>();
                getEndpoint().getBedrockRuntimeAsyncClient().converseStream(
                        request,
                        org.apache.camel.component.aws2.bedrock.runtime.stream.ConverseStreamHandler.createChunksHandler(
                                metadata,
                                allChunks,
                                null))
                        .join();

                message.setBody(allChunks);
                if (getConfiguration().isIncludeStreamingMetadata()) {
                    setConverseStreamingMetadata(message, metadata);
                }
            } else {
                 
                StringBuilder fullText = new StringBuilder();
                getEndpoint().getBedrockRuntimeAsyncClient().converseStream(
                        request,
                        org.apache.camel.component.aws2.bedrock.runtime.stream.ConverseStreamHandler.createCompleteHandler(
                                metadata,
                                fullText))
                        .join();

                message.setBody(fullText.toString());
                if (getConfiguration().isIncludeStreamingMetadata()) {
                    setConverseStreamingMetadata(message, metadata);
                }
            }

        } catch (AwsServiceException ase) {
            LOG.trace("Converse Stream command returned the error code {}", ase.awsErrorDetails().errorCode());
            throw ase;
        }
    }

    public Processor createProcessor() throws Exception {
        ObjectHelper.notNull(definition.getName(), "propertyName", this);
        Expression expr = createExpression(definition.getExpression());
        Expression nameExpr;
        String key = parseString(definition.getName());
        if (LanguageSupport.hasSimpleFunction(key)) {
            nameExpr = camelContext.resolveLanguage("simple").createExpression(key);
        } else {
            nameExpr = camelContext.resolveLanguage("constant").createExpression(key);
        }
        nameExpr.init(camelContext);

        SetPropertyProcessor answer = new SetPropertyProcessor(nameExpr, expr);
        answer.setDisabled(isDisabled(camelContext, definition));
        return answer;
    }

    public Gmail getClient(GoogleMailConfiguration config) {
        if (client == null) {
            if (config.getClientId() != null && !config.getClientId().isBlank()
                    && config.getClientSecret() != null && !config.getClientSecret().isBlank()) {
                client = getClientFactory().makeClient(config.getClientId(),
                        config.getClientSecret(), config.getScopesAsList(),
                        config.getApplicationName(), config.getRefreshToken(), config.getAccessToken());
            } else if (config.getServiceAccountKey() != null && !config.getServiceAccountKey().isBlank()) {
                client = getClientFactory().makeClient(getCamelContext(), config.getServiceAccountKey(),
                        config.getScopesAsList(), config.getApplicationName(), config.getDelegate());
            } else {
                throw new IllegalArgumentException(
                        "(clientId and clientSecret) or serviceAccountKey are required to create Gmail client");
            }
        }
        return client;
    }

    protected void doList(Exchange exchange) {
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        DeploymentList deploymentsList;

        if (ObjectHelper.isEmpty(namespace)) {
            deploymentsList = getEndpoint().getKubernetesClient().apps().deployments().inAnyNamespace().list();
        } else {
            deploymentsList = getEndpoint().getKubernetesClient().apps().deployments().inNamespace(namespace).list();
        }

        prepareOutboundMessage(exchange, deploymentsList.getItems());
    }

    protected static List<String> getParameters(String path) {
        if (path == null) {
            LOG.warn("The provided path is null and has no parameters to be evaluated");
            return Collections.emptyList();
        }

        List<String> parameters = null;

        int startIndex = path.indexOf('{');
        while (startIndex != -1) {
            int endIndex = path.indexOf('}', startIndex);
            if (endIndex != -1) {
                if (parameters == null) {
                    parameters = new ArrayList<>();
                }
                parameters.add(path.substring(startIndex + 1, endIndex));
                startIndex = path.indexOf('{', endIndex);
            } else {
                 
                startIndex = -1;
            }
        }

        return parameters == null ? Collections.emptyList() : parameters;
    }

    public static Predicate startsWith(final Expression left, final Expression right) {
        return new BinaryPredicateSupport(left, right) {

            protected boolean matches(Exchange exchange, Object leftValue, Object rightValue) {
                return LanguageHelper.startsWith(exchange, leftValue, rightValue);
            }

            protected String getOperationText() {
                return "startsWith";
            }
        };
    }

    public void process(Exchange exchange) throws Exception {
        String remotePath = DropboxHelper.getRemotePath(configuration, exchange);
        String localPath = DropboxHelper.getLocalPath(configuration, exchange);
        DropboxUploadMode uploadMode = DropboxHelper.getUploadMode(configuration, exchange);

        DropboxConfigurationValidator.validatePutOp(localPath, remotePath, uploadMode);

        DropboxFileUploadResult result = new DropboxAPIFacade(configuration.getClient(), exchange)
                .put(localPath, remotePath, uploadMode);

        Map<String, DropboxResultCode> map = result.getResults();
        if (map.size() == 1) {
            for (Map.Entry<String, DropboxResultCode> entry : map.entrySet()) {
                exchange.getIn().setHeader(DropboxConstants.UPLOADED_FILE, entry.getKey());
                exchange.getIn().setBody(entry.getValue());
            }

        } else {
            StringBuilder pathsExtracted = new StringBuilder();
            for (Map.Entry<String, DropboxResultCode> entry : map.entrySet()) {
                pathsExtracted.append(entry.getKey()).append('\n');
            }
            exchange.getIn().setHeader(DropboxConstants.UPLOADED_FILES, pathsExtracted.toString());
            exchange.getIn().setBody(map);
        }

        if (LOG.isDebugEnabled()) {
            LOG.debug("Uploaded: {}", result);
        }
    }

    public static MainModel generateMainModel(JsonObject obj) {
        MainModel model = new MainModel();
        JsonArray mgrp = (JsonArray) obj.get("groups");
        for (Object entry : mgrp) {
            JsonObject mg = (JsonObject) entry;
            MainGroupModel group = new MainGroupModel();
            parseGroup(mg, group);
            model.addGroup(group);
        }
        JsonArray mprp = (JsonArray) obj.get("properties");
        for (Object entry : mprp) {
            JsonObject mp = (JsonObject) entry;
            MainOptionModel option = new MainOptionModel();
            parseOption(mp, option, mp.getString("name"));
            option.setSourceType(mp.getString("sourceType"));
            model.addOption(option);
        }
        return model;
    }

    public RestDefinition id(String id) {
        if (getVerbs().isEmpty()) {
            super.id(id);
        } else {
             
            VerbDefinition verb = getVerbs().get(getVerbs().size() - 1);
            verb.id(id);
        }

        return this;
    }

    protected void doDumpRoutesAsYaml(CamelContext camelContext) {
        final ModelToYAMLDumper dumper = PluginHelper.getModelToYAMLDumper(camelContext);
        final Model model = camelContext.getCamelContextExtension().getContextPlugin(Model.class);
        final DummyResource dummy = new DummyResource(null, null);
        final Set<String> files = new HashSet<>();

        if (include.contains("*") || include.contains("all") || include.contains("beans")) {
            int size = model.getCustomBeans().size();
            if (size > 0) {
                Map<Resource, List<BeanFactoryDefinition>> groups = new LinkedHashMap<>();
                for (BeanFactoryDefinition bean : model.getCustomBeans()) {
                    Resource res = bean.getResource();
                    if (res == null) {
                        res = dummy;
                    }
                    List<BeanFactoryDefinition> beans = groups.computeIfAbsent(res, resource -> new ArrayList<>());
                    beans.add(bean);
                }
                StringBuilder sbLog = new StringBuilder();
                for (Map.Entry<Resource, List<BeanFactoryDefinition>> entry : groups.entrySet()) {
                    List<BeanFactoryDefinition> beans = entry.getValue();
                    Resource resource = entry.getKey();

                    StringBuilder sbLocal = new StringBuilder();
                    doDumpYamlBeans(camelContext, beans, resource == dummy ? null : resource, dumper, "beans", sbLocal, sbLog);
                     
                    doDumpToDirectory(resource, sbLocal, "beans", "yaml", files);
                }
                if (!sbLog.isEmpty() && log) {
                    LOG.info("Dumping {} beans as YAML", size);
                    LOG.info("{}", sbLog);
                }
            }
        }

        if (include.contains("*") || include.contains("all") || include.contains("dataFormats")) {
            int size = model.getDataFormats().size();
            if (size > 0) {
                Map<Resource, Map<String, DataFormatDefinition>> groups = new LinkedHashMap<>();
                for (Map.Entry<String, DataFormatDefinition> entry : model.getDataFormats().entrySet()) {
                    Resource res = entry.getValue().getResource();
                    if (res == null) {
                        res = dummy;
                    }
                    Map<String, DataFormatDefinition> dfs = groups.computeIfAbsent(res, resource -> new LinkedHashMap<>());
                    dfs.put(entry.getKey(), entry.getValue());
                }
                StringBuilder sbLog = new StringBuilder();
                for (Map.Entry<Resource, Map<String, DataFormatDefinition>> entry : groups.entrySet()) {
                    Map<String, DataFormatDefinition> dfs = entry.getValue();
                    Resource resource = entry.getKey();

                    StringBuilder sbLocal = new StringBuilder();
                    doDumpYamlDataFormats(camelContext, dfs, resource == dummy ? null : resource, dumper, "dataFormats",
                            sbLocal, sbLog);
                     
                    doDumpToDirectory(resource, sbLocal, "dataFormats", "yaml", files);
                }
                if (!sbLog.isEmpty() && log) {
                    LOG.info("Dumping {} data formats as YAML", size);
                    LOG.info("{}", sbLog);
                }
            }
        }

        if (include.contains("*") || include.contains("all") || include.contains("rests")) {
            int size = model.getRestDefinitions().size();
            if (size > 0) {
                Map<Resource, RestsDefinition> groups = new LinkedHashMap<>();
                for (RestDefinition rest : model.getRestDefinitions()) {
                    Resource res = rest.getResource();
                    if (res == null) {
                        res = dummy;
                    }
                    RestsDefinition rests = groups.computeIfAbsent(res, resource -> new RestsDefinition());
                    rests.getRests().add(rest);
                }
                StringBuilder sbLog = new StringBuilder();
                for (Map.Entry<Resource, RestsDefinition> entry : groups.entrySet()) {
                    RestsDefinition def = entry.getValue();
                    Resource resource = entry.getKey();

                    StringBuilder sbLocal = new StringBuilder();
                    doDumpYaml(camelContext, def, resource == dummy ? null : resource, dumper, "rests", sbLocal, sbLog);
                     
                    doDumpToDirectory(resource, sbLocal, "rests", "yaml", files);
                }
                if (!sbLog.isEmpty() && log) {
                    LOG.info("Dumping {} rests as YAML", size);
                    LOG.info("{}", sbLog);
                }
            }
        }

        if (include.contains("*") || include.contains("all") || include.contains("routeConfigurations")
                || include.contains("route-configurations")) {
            int size = model.getRouteConfigurationDefinitions().size();
            if (size > 0) {
                Map<Resource, RouteConfigurationsDefinition> groups = new LinkedHashMap<>();
                for (RouteConfigurationDefinition config : model.getRouteConfigurationDefinitions()) {
                    Resource res = config.getResource();
                    if (res == null) {
                        res = dummy;
                    }
                    RouteConfigurationsDefinition routes
                            = groups.computeIfAbsent(res, resource -> new RouteConfigurationsDefinition());
                    routes.getRouteConfigurations().add(config);
                }
                StringBuilder sbLog = new StringBuilder();
                for (Map.Entry<Resource, RouteConfigurationsDefinition> entry : groups.entrySet()) {
                    RouteConfigurationsDefinition def = entry.getValue();
                    Resource resource = entry.getKey();

                    StringBuilder sbLocal = new StringBuilder();
                    doDumpYaml(camelContext, def, resource == dummy ? null : resource, dumper, "route-configurations", sbLocal,
                            sbLog);
                     
                    doDumpToDirectory(resource, sbLocal, "route-configurations", "yaml", files);
                }
                if (!sbLog.isEmpty() && log) {
                    LOG.info("Dumping {} route-configurations as YAML", size);
                    LOG.info("{}", sbLog);
                }
            }
        }

        if (include.contains("*") || include.contains("all") || include.contains("routeTemplates")
                || include.contains("route-templates")) {
            int size = model.getRouteTemplateDefinitions().size();
            if (size > 0) {
                Map<Resource, RouteTemplatesDefinition> groups = new LinkedHashMap<>();
                for (RouteTemplateDefinition rt : model.getRouteTemplateDefinitions()) {
                    Resource res = rt.getResource();
                    if (res == null) {
                        res = dummy;
                    }
                    RouteTemplatesDefinition rests = groups.computeIfAbsent(res, resource -> new RouteTemplatesDefinition());
                    rests.getRouteTemplates().add(rt);
                }
                StringBuilder sbLog = new StringBuilder();
                for (Map.Entry<Resource, RouteTemplatesDefinition> entry : groups.entrySet()) {
                    RouteTemplatesDefinition def = entry.getValue();
                    Resource resource = entry.getKey();

                    StringBuilder sbLocal = new StringBuilder();
                    doDumpYaml(camelContext, def, resource == dummy ? null : resource, dumper, "route-templates", sbLocal,
                            sbLog);
                     
                    doDumpToDirectory(resource, sbLocal, "route-templates", "yaml", files);
                }
                if (!sbLog.isEmpty() && log) {
                    LOG.info("Dumping {} route-templates as YAML", size);
                    LOG.info("{}", sbLog);
                }
            }
        }

        if (include.contains("*") || include.contains("all") || include.contains("routes")) {
            int size = model.getRouteDefinitions().size();
            if (size > 0) {
                Map<Resource, RoutesDefinition> groups = new LinkedHashMap<>();
                for (RouteDefinition route : model.getRouteDefinitions()) {
                    if ((route.isRest() != null && route.isRest()) || (route.isTemplate() != null && route.isTemplate())) {
                         
                        continue;
                    }
                    Resource res = route.getResource();
                    if (res == null) {
                        res = dummy;
                    }
                    RoutesDefinition routes = groups.computeIfAbsent(res, resource -> new RoutesDefinition());
                    routes.getRoutes().add(route);
                }
                StringBuilder sbLog = new StringBuilder();
                for (Map.Entry<Resource, RoutesDefinition> entry : groups.entrySet()) {
                    RoutesDefinition def = entry.getValue();
                    Resource resource = entry.getKey();

                    StringBuilder sbLocal = new StringBuilder();
                    doDumpYaml(camelContext, def, resource == dummy ? null : resource, dumper, "routes", sbLocal, sbLog);
                     
                    doDumpToDirectory(resource, sbLocal, "routes", "yaml", files);
                }
                if (!sbLog.isEmpty() && log) {
                    LOG.info("Dumping {} routes as YAML", size);
                    LOG.info("{}", sbLog);
                }
            }
        }

    }

    protected void doInit() throws Exception {
        super.doInit();
        if (meter == null) {
            this.meter = CamelContextHelper.findSingleByType(getCamelContext(), Meter.class);
        }
        if (meter == null) {
             
            this.meter = GlobalOpenTelemetry.get().getMeter("camel");
        }
        if (meter == null) {
            throw new RuntimeCamelException("Could not find any OpenTelemetry meter!");
        }
    }

    public static String parseVariables(String url, Server server) {
        Pattern p = Pattern.compile("\\{(.*?)\\}");
        Matcher m = p.matcher(url);
        while (m.find()) {

            String variable = m.group(1);
            if (server != null && server.getVariables() != null && server.getVariables().get(variable) != null) {
                String varValue = server.getVariables().get(variable).getDefault();
                url = url.replace("{" + variable + "}", varValue);
            }
        }
        return url;
    }

    private void createClient(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().create((ClientRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            ClientRepresentation client = new ClientRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.CLIENT_ID))) {
                String clientId = exchange.getIn().getHeader(KeycloakConstants.CLIENT_ID, String.class);
                client.setClientId(clientId);
                client.setEnabled(true);
            } else {
                throw new IllegalArgumentException(MISSING_CLIENT_ID);
            }
            Response response = keycloakClient.realm(realmName).clients().create(client);
            Message message = getMessageForResponse(exchange);
            message.setBody(response);
        }
    }

    public Object sendBodyAndProperty(
            Endpoint endpoint, ExchangePattern pattern, final Object body,
            final String property, final Object propertyValue)
            throws CamelExecutionException {
        Exchange exchange = send(endpoint, pattern, createBodyAndPropertyProcessor(body, property, propertyValue));
        Object result = extractResultBody(exchange, pattern);
        if (pattern == ExchangePattern.InOnly) {
             
            return null;
        } else {
            return result;
        }
    }

    private String getUri(Row r) {
        String u = r.endpointUri;
        if (shortUri) {
            int pos = u.indexOf('?');
            if (pos > 0) {
                u = u.substring(0, pos);
            }
        }
        return u;
    }

    private static void parseApplicationEDIEntity(
            HttpMessage message, InputStream is, AS2SessionInputBuffer inBuffer, ContentType contentType,
            String contentTransferEncoding)
            throws HttpException {
        ApplicationEntity applicationEntity = null;

        ObjectHelper.notNull(message, "message");
        ObjectHelper.notNull(inBuffer, "inBuffer");

        HttpEntity entity = ObjectHelper.notNull(EntityUtils.getMessageEntity(message), "message entity");

        if (entity instanceof ApplicationEntity) {
             
            return;
        }

        Args.check(entity.isStreaming(), "Message entity can not be parsed: entity is not streaming");

        try {

            applicationEntity = parseEDIEntityBody(inBuffer, is, null, contentType, contentTransferEncoding, "");
            applicationEntity.setMainBody(true);

            EntityUtils.setMessageEntity(message, applicationEntity);

        } catch (Exception e) {
            throw new HttpException("Failed to parse entity content", e);
        }
    }

    private void add(Exchange exchange) throws Exception {
        final Message in = exchange.getMessage();

        String collectionName = getCollectionName(in);
        Collection collection = this.client.getCollection(collectionName, embeddingFunction);

        List<String> ids = in.getHeader(ChromaHeaders.IDS, List.class);
        List<Embedding> embeddings = getEmbeddings(in);
        List<Map<String, String>> metadatas = in.getHeader(ChromaHeaders.METADATAS, List.class);
        List<String> documents = in.getBody(List.class);

        collection.add(embeddings, metadatas, documents, ids);
        in.setHeader(ChromaHeaders.OPERATION_STATUS, "SUCCESS");
    }

    protected void doStop() throws Exception {
        super.doStop();

        LOG.debug("Stopping Kubernetes ConfigMap Consumer");
        if (executor != null) {
            KubernetesHelper.close(configMapWatcher, configMapWatcher::getWatch);

            if (getEndpoint() != null && getEndpoint().getCamelContext() != null) {
                getEndpoint().getCamelContext().getExecutorServiceManager().shutdownNow(executor);
            } else {
                executor.shutdownNow();
            }
        }
        executor = null;
    }

    public <T> Map<String, T> findByTypeWithName(Class<T> type) {
        Map<String, T> result = new HashMap<>();
         
        String keyPrefix = type.getName().replace('$', '/');
        kvClient = consul.keyValueClient();

        List<String> keys;
        try {
            keys = kvClient.getKeys(keyPrefix);
        } catch (ConsulException e) {
            return result;
        }

        if (keys != null) {
            Object obj;

            for (String key : keys) {
                 
                key = key.substring(key.lastIndexOf('/') + 1);
                obj = lookupByName(key.replace('$', '/'));
                if (type.isInstance(obj)) {
                    result.put(key, type.cast(obj));
                }
            }
        }
        return result;
    }

    JsonObject loadStatus(long pid) {
        try {
            Path f = getStatusFile(Long.toString(pid));
            if (f != null && Files.exists(f)) {
                String text = Files.readString(f);
                return (JsonObject) Jsoner.deserialize(text);
            }
        } catch (Exception e) {
             
        }
        return null;
    }

    private void configureTimeoutExecutorService(ResilienceProcessor processor, Resilience4jConfigurationCommon config) {
        if (!parseBoolean(config.getTimeoutEnabled(), false)) {
            return;
        }

        if (config.getTimeoutExecutorService() != null) {
            String ref = config.getTimeoutExecutorService();
            boolean shutdownThreadPool = false;
            ExecutorService executorService = lookupByNameAndType(ref, ExecutorService.class);
            if (executorService == null) {
                executorService = lookupExecutorServiceRef("CircuitBreaker", definition, ref);
                shutdownThreadPool = true;
            }
            processor.setExecutorService(executorService);
            processor.setShutdownExecutorService(shutdownThreadPool);
        }
    }

    public void forceDisconnect() throws GenericFileOperationFailedException {
        lock.lock();
        try {
            if (session != null) {
                session.disconnect();
            }
            if (channel != null) {
                channel.disconnect();
            }
        } finally {
             
            session = null;
            channel = null;
            lock.unlock();
        }
    }

    public <T> T convertTo(Class<?> from, Class<T> to, Exchange exchange, Object value) throws TypeConversionException {
        try {
            Object obj = doConvertTo(from, to, exchange, value);
            return (T) obj;
        } catch (TypeConversionException e) {
            throw e;
        } catch (Exception e) {
            throw new TypeConversionException(value, to, e);
        }
    }

    public <T extends Collection<?>> T getCollectionOrDefault(final String key, final T defaultValue) {
         
        Object returnable;
        if (this.containsKey(key)) {
            returnable = this.get(key);
        } else {
            return defaultValue;
        }
        return (T) returnable;
    }

    private void processExecuteAsyncReport(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {

        String reportId;
        final Boolean includeDetails = getParameter(INCLUDE_DETAILS, exchange, IGNORE_BODY, IS_OPTIONAL, Boolean.class);

         
        ReportMetadata reportMetadata = exchange.getIn().getBody(ReportMetadata.class);
        if (reportMetadata != null) {
            reportId = reportMetadata.getId();
            if (reportId == null) {
                reportId = getParameter(REPORT_ID, exchange, IGNORE_BODY, NOT_OPTIONAL);
            }
        } else {
            reportId = getParameter(REPORT_ID, exchange, USE_BODY, NOT_OPTIONAL);
            reportMetadata = getParameter(REPORT_METADATA, exchange, IGNORE_BODY, IS_OPTIONAL, ReportMetadata.class);
        }

        analyticsClient.executeAsyncReport(reportId, includeDetails, reportMetadata, determineHeaders(exchange),
                new AnalyticsApiClient.ReportInstanceResponseCallback() {
                    @Override
                    public void onResponse(ReportInstance reportInstance, Map<String, String> headers, SalesforceException ex) {
                        processResponse(exchange, reportInstance, headers, ex, callback);
                    }
                });
    }

    private static String evaluateTemplate(final String templateName, final MainModel model) throws MojoExecutionException {
        StringBuilder sb = new StringBuilder(256);

        try (InputStream templateStream = UpdateReadmeMojo.class.getClassLoader().getResourceAsStream(templateName)) {
            String template = PackageHelper.loadText(templateStream);
             
            for (MainModel.MainGroupModel group : model.getGroups()) {
                Map<String, Object> root = new HashMap<>();
                root.put("group", group);
                root.put("options", model.getOptions().stream()
                        .filter(o -> o.getName().startsWith(group.getName()))
                        .toList());
                String eval
                        = (String) TemplateRuntime.eval(template, root, Collections.singletonMap("util", MvelHelper.INSTANCE));
                sb.append(eval);
                sb.append("\n");
            }
        } catch (IOException e) {
            throw new MojoExecutionException("Error processing mvel template `" + templateName + "`", e);
        }

        return sb.toString();
    }

    private Consumer<CosmosContainerResponse> setCosmosContainerResponseOnExchange(final Exchange exchange) {
        return response -> {
            if (ObjectHelper.isNotEmpty(response.getProperties())) {
                setMessageHeader(exchange, CosmosDbConstants.RESOURCE_ID, response.getProperties().getResourceId());
                setMessageHeader(exchange, CosmosDbConstants.E_TAG, response.getProperties().getETag());
                setMessageHeader(exchange, CosmosDbConstants.TIMESTAMP, response.getProperties().getTimestamp());
                setMessageHeader(exchange, CosmosDbConstants.DEFAULT_TIME_TO_LIVE_SECONDS,
                        response.getProperties().getDefaultTimeToLiveInSeconds());
            }
            setCommonResponseOnExchange(exchange, response);
        };
    }

    public void pre(SpanAdapter span, Exchange exchange, Endpoint endpoint) {
        super.pre(span, exchange, endpoint);

        String partition = getValue(exchange, PARTITION, Integer.class);
        if (partition != null) {
            span.setTag(KAFKA_PARTITION_TAG, partition);
        }

        String partitionKey = exchange.getIn().getHeader(PARTITION_KEY, String.class);
        if (partitionKey != null) {
            span.setTag(KAFKA_PARTITION_KEY_TAG, partitionKey);
        }

        String key = exchange.getIn().getHeader(KEY, String.class);
        if (key != null) {
            span.setTag(KAFKA_KEY_TAG, key);
        }

        String offset = getValue(exchange, OFFSET, String.class);
        if (offset != null) {
            span.setTag(KAFKA_OFFSET_TAG, offset);
        }
    }

    protected ReplyManager createReplyManager() throws Exception {
         
        ReplyManager temporaryQueueReplyManager = new TemporaryQueueReplyManager(getEndpoint().getCamelContext());
        temporaryQueueReplyManager.setEndpoint(getEndpoint());

        String name = "JmsReplyManagerTimeoutChecker[" + getEndpoint().getEndpointConfiguredDestinationName() + "]";
        ScheduledExecutorService replyManagerScheduledExecutorService
                = getEndpoint().getCamelContext().getExecutorServiceManager().newSingleThreadScheduledExecutor(this, name);
        temporaryQueueReplyManager.setScheduledExecutorService(replyManagerScheduledExecutorService);

        name = "JmsReplyManagerOnTimeout[" + getEndpoint().getEndpointConfiguredDestinationName() + "]";
         
        ExecutorService replyManagerExecutorService = createReplyManagerExecutor(temporaryQueueReplyManager, name);
        temporaryQueueReplyManager.setOnTimeoutExecutorService(replyManagerExecutorService);

        ServiceHelper.startService(temporaryQueueReplyManager);

        return temporaryQueueReplyManager;
    }

    private void updateIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String idpAlias = exchange.getIn().getHeader(KeycloakConstants.IDP_ALIAS, String.class);
        if (ObjectHelper.isEmpty(idpAlias)) {
            throw new IllegalArgumentException("Identity provider alias must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                keycloakClient.realm(realmName).identityProviders().get(idpAlias)
                        .update((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Identity provider updated successfully");
            }
        } else {
            throw new IllegalArgumentException(
                    "Update identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void closeLockFiles() {
        if (leaderLockFile != null) {
            try {
                leaderLockFile.close();
            } catch (Exception ignore) {
                LOGGER.warn("{}", ignore.getMessage(), ignore);
            }
            leaderLockFile = null;
        }

        if (leaderDataFile != null) {
            try {
                leaderDataFile.close();
            } catch (Exception ignore) {
                LOGGER.warn("{}", ignore.getMessage(), ignore);
            }
            leaderDataFile = null;
        }
    }

    public void shutdown() {
        lock.lock();
        try {
            if (status == SHUTDOWN) {
                logger().trace("Service: {} already shutdown", this);
                return;
            }
            if (status == SHUTTING_DOWN) {
                logger().trace("Service: {} already shutting down", this);
                return;
            }
            stop();
            status = SHUTDOWN;
            logger().trace("Shutting down service: {}", this);
            try (AutoCloseable ignored = doLifecycleChange()) {
                doShutdown();
                logger().trace("Shutdown service: {}", this);
                status = SHUTDOWN;
            } catch (Exception e) {
                logger().trace("Error shutting down service: {}", this, e);
                fail(e);
            }
        } finally {
            lock.unlock();
        }
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.apache.solr.client.solrj.request.ContentStreamUpdateRequest.class, java.lang.Object.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.solr.converter.SolrRequestConverter.createContentStreamUpdateRequest(value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.solr.client.solrj.request.QueryRequest.class, java.lang.Object.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.solr.converter.SolrRequestConverter.createQueryRequest(value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.solr.client.solrj.request.SolrPing.class, java.lang.Object.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.solr.converter.SolrRequestConverter.createSolrPing(value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.solr.client.solrj.request.UpdateRequest.class, java.lang.Object.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.solr.converter.SolrRequestConverter.createUpdateRequest(value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    public V put(K key, V value, long timeoutMillis) {
        TimeoutMapEntry<K, V> entry = new TimeoutMapEntry<>(key, value, timeoutMillis);
        lock.lock();
        try {
            updateExpireTime(entry);
            TimeoutMapEntry<K, V> result = map.put(key, entry);
            return unwrap(result);
        } finally {
            lock.unlock();
            emitEvent(Put, key, value);
        }
    }

    private void processCreateJob(Exchange exchange, AsyncCallback callback)
            throws InvalidPayloadException {
        Job job = exchange.getIn().getMandatoryBody(Job.class);
        bulkClient.createJob(job, determineHeaders(exchange),
                new JobResponseCallback() {
                    @Override
                    public void onResponse(Job job, Map<String, String> headers, SalesforceException ex) {
                        processResponse(exchange, job, headers, ex, callback);
                    }
                });
    }

    private String detectMimeType(File file, Exchange exchange) {
         
        String mediaTypeStr = exchange.getIn().getHeader(SpringAiChatConstants.MEDIA_TYPE, String.class);
        if (mediaTypeStr != null) {
            return mediaTypeStr;
        }

         
        String fileContentType = exchange.getIn().getHeader(Exchange.FILE_CONTENT_TYPE, String.class);
        if (fileContentType != null) {
            return fileContentType;
        }

         
        String fileName = file.getName().toLowerCase();

         
        if (fileName.endsWith(".png")) {
            return "image/png";
        } else if (fileName.endsWith(".jpg") || fileName.endsWith(".jpeg")) {
            return "image/jpeg";
        } else if (fileName.endsWith(".gif")) {
            return "image/gif";
        } else if (fileName.endsWith(".webp")) {
            return "image/webp";
        } else if (fileName.endsWith(".bmp")) {
            return "image/bmp";
        } else if (fileName.endsWith(".tiff") || fileName.endsWith(".tif")) {
            return "image/tiff";
        } else if (fileName.endsWith(".svg")) {
            return "image/svg+xml";
        }
         
        else if (fileName.endsWith(".mp4")) {
            return "video/mp4";
        } else if (fileName.endsWith(".webm")) {
            return "video/webm";
        } else if (fileName.endsWith(".mov")) {
            return "video/quicktime";
        } else if (fileName.endsWith(".mkv")) {
            return "video/x-matroska";
        } else if (fileName.endsWith(".flv")) {
            return "video/x-flv";
        } else if (fileName.endsWith(".mpeg") || fileName.endsWith(".mpg")) {
            return "video/mpeg";
        } else if (fileName.endsWith(".wmv")) {
            return "video/x-ms-wmv";
        } else if (fileName.endsWith(".3gp")) {
            return "video/3gpp";
        }
         
        else if (fileName.endsWith(".wav")) {
            return "audio/wav";
        } else if (fileName.endsWith(".mp3")) {
            return "audio/mpeg";  
        } else if (fileName.endsWith(".ogg")) {
            return "audio/ogg";
        } else if (fileName.endsWith(".m4a")) {
            return "audio/mp4";  
        } else if (fileName.endsWith(".flac")) {
            return "audio/flac";
        }
         
        else if (fileName.endsWith(".pdf")) {
            return "application/pdf";
        } else if (fileName.endsWith(".csv")) {
            return "text/csv";
        } else if (fileName.endsWith(".doc")) {
            return "application/msword";
        } else if (fileName.endsWith(".docx")) {
            return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
        } else if (fileName.endsWith(".xls")) {
            return "application/vnd.ms-excel";
        } else if (fileName.endsWith(".xlsx")) {
            return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
        } else if (fileName.endsWith(".html") || fileName.endsWith(".htm")) {
            return "text/html";
        } else if (fileName.endsWith(".txt")) {
            return "text/plain";
        } else if (fileName.endsWith(".md")) {
            return "text/markdown";
        }

         
        LOG.debug("Could not detect MIME type from file extension: {}, defaulting to image/png", fileName);
        return "image/png";
    }

    public Integer doCall() throws Exception {
        List<Long> pids = findPids(name);
        for (long pid : pids) {
            JsonObject root = new JsonObject();
            root.put("action", "reset-stats");
            Path f = getActionFile(Long.toString(pid));
            Files.writeString(f, root.toJson());
        }

        return 0;
    }

    public void addConsumer(String key, DirectConsumer consumer) {
        consumersLock.lock();
        try {
            if (consumers.putIfAbsent(key, consumer) != null) {
                throw new IllegalArgumentException(
                        "Cannot add a 2nd consumer to the same endpoint: " + key
                                                   + ". DirectEndpoint only allows one consumer.");
            }
             
            stateCounter++;
            consumersCondition.signalAll();
        } finally {
            consumersLock.unlock();
        }
    }

    private List<SplunkEvent> realtimeSearch(SplunkResultProcessor callback) throws Exception {
        LOG.debug("realtime search start");

        JobArgs queryArgs = new JobArgs();
        queryArgs.setExecutionMode(ExecutionMode.NORMAL);
        queryArgs.setSearchMode(SearchMode.REALTIME);
        Calendar startTime = Calendar.getInstance();
        populateArgs(queryArgs, startTime, true);

        List<SplunkEvent> data = runQuery(queryArgs, true, callback);
        lastSuccessfulReadTime = startTime;
        return data;
    }

    public Map<String, Object> endpointProperties(Exchange exchange, String uri) throws Exception {
        Map<String, Object> properties;
         
        Map<String, Object> map = URISupport.parseQuery(URISupport.extractQuery(uri));
        if (map != null && !map.isEmpty() && isLenientProperties()) {
            if (resolveRawParameterValues()) {
                 
                 
                 
                RawParameterHelper.resolveRawParameterValues(exchange.getContext(), map);
            }
             
            properties = new LinkedHashMap<>();
            map.forEach((k, v) -> {
                boolean accept = knownProperties.contains(k);
                 
                 
                if (!accept && !knownPrefixes.isEmpty()) {
                    accept = knownPrefixes.values().stream().anyMatch(k::startsWith);
                }
                if (accept) {
                    properties.put(k, v);
                }
            });
        } else {
            properties = map;
        }

        return properties;
    }

    public void execute() throws MojoExecutionException, MojoFailureException {
        if ("pom".equals(project.getPackaging())) {
            return;
        }

        buildDir = new File(project.getBuild().getDirectory());

        if (resourcesOutputDir == null) {
            resourcesOutputDir = new File(project.getBasedir(), "src/generated/resources");
        }

        Index index = PackagePluginUtils.readJandexIndexIgnoreMissing(project, getLog());
        if (index == null) {
            return;
        }

        List<DataTypeTransformerModel> models = new ArrayList<>();
        List<AnnotationInstance> annotations = index.getAnnotations(DATA_TYPE_ANNOTATION);
        annotations.forEach(a -> {
            DataTypeTransformerModel model = new DataTypeTransformerModel();

            String currentClass = a.target().asClass().name().toString();
            boolean deprecated
                    = a.target().asClass().hasAnnotation(Deprecated.class) || project.getName().contains("(deprecated)");
            model.setClassName(currentClass);
            model.setDeprecated(deprecated);
            model.setName(annotationValue(a, "name"));
            model.setFrom(annotationValue(a, "from"));
            model.setTo(annotationValue(a, "to"));
            model.setDescription(annotationValue(a, "description"));
            models.add(model);
        });
        models.sort(Comparator.comparing(DataTypeTransformerModel::getName));

        if (!models.isEmpty()) {
            try {
                StringJoiner names = new StringJoiner(" ");
                for (var model : models) {
                    names.add(model.getName());

                    JsonObject jo = asJsonObject(model);
                    String json = jo.toJson();
                    json = Jsoner.prettyPrint(json, 2);
                    String fn = sanitizeFileName(model.getName()) + PackageHelper.JSON_SUFIX;
                    boolean updated = updateResource(resourcesOutputDir.toPath(),
                            "META-INF/services/org/apache/camel/transformer/" + fn,
                            json + NL);
                    if (updated) {
                        getLog().info("Updated transformer json: " + model.getName());
                    }
                }

                 
                File camelMetaDir = new File(resourcesOutputDir, "META-INF/services/org/apache/camel/");
                int count = models.size();
                String properties = createProperties(project, "transformers", names.toString());
                updateResource(camelMetaDir.toPath(), "transformer.properties", properties);
                getLog().info("Generated transformer.properties containing " + count + " Camel "
                              + (count > 1 ? "transformers: " : "transformer: ") + names);
            } catch (Exception e) {
                throw new MojoExecutionException(e);
            }
        }
    }

    SSLContext provideSSLContext() throws GeneralSecurityException, IOException {
        if (sslContextParameters != null) {
            return sslContextParameters.createSSLContext(getCamelContext());
        } else if (getComponent().getSslContextParameters() != null) {
            return getComponent().getSslContextParameters().createSSLContext(getCamelContext());
        } else {
            return null;
        }
    }

    protected void doResume() throws Exception {
         
        if (!initialized) {
            doStart();
        } else {
            if (listenerContainer != null) {
                startListenerContainer();
            } else {
                LOG.warn(
                        "The listenerContainer is not instantiated. Probably there was a timeout during the Suspend operation. Please restart your consumer route.");
            }
        }
    }

    public String dumpStatisticsAsJsonTimeUnitSeconds() {
        ObjectWriter writer = secondsMapper.writer();
        if (isPrettyPrint()) {
            writer = writer.withDefaultPrettyPrinter();
        }
        try {
            return writer.writeValueAsString(getMeterRegistry());
        } catch (JsonProcessingException e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        }
    }

    protected Boolean omitXmlDeclaration(Message message, Input input) {
        Boolean omitXmlDeclaration = message.getHeader(XmlSignatureConstants.HEADER_OMIT_XML_DECLARATION, Boolean.class);
        if (omitXmlDeclaration == null) {
            omitXmlDeclaration = input.omitXmlDeclaration();
        }
        if (omitXmlDeclaration == null) {
            omitXmlDeclaration = Boolean.FALSE;
        }
        return omitXmlDeclaration;
    }

    public Exchange add(CamelContext camelContext, String key, Exchange oldExchange, Exchange newExchange)
            throws OptimisticLockingException {
        if (!optimistic) {
            throw new UnsupportedOperationException();
        }

        LOG.trace("Adding an Exchange with ID {} for key {} in an optimistic manner.", newExchange.getExchangeId(), key);
        if (oldExchange == null) {
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            DefaultExchangeHolder oldHolder = cache.getAndPut(key, newHolder);
            if (oldHolder != null) {
                Exchange exchange = unmarshallExchange(camelContext, oldHolder);
                LOG.error(
                        "Optimistic locking failed for exchange with key {}: IMap#putIfAbsend returned Exchange with ID {}, while it's expected no exchanges to be returned",
                        key,
                        exchange != null ? exchange.getExchangeId() : "<null>");

                throw new OptimisticLockingException();
            }
        } else {
            DefaultExchangeHolder oldHolder = DefaultExchangeHolder.marshal(oldExchange, true, allowSerializedHeaders);
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            if (!cache.replace(key, oldHolder, newHolder)) {
                LOG.error(
                        "Optimistic locking failed for exchange with key {}: IMap#replace returned no Exchanges, while it's expected to replace one",
                        key);
                throw new OptimisticLockingException();
            }
        }
        LOG.trace("Added an Exchange with ID {} for key {} in optimistic manner.", newExchange.getExchangeId(), key);
        return oldExchange;
    }

    protected void afterConfigureProperties() {
        olingo4endpointPropertyNames
                = new HashSet<>(getPropertiesHelper().getValidEndpointProperties(getCamelContext(), configuration));
        olingo4endpointPropertyNames.add(EDM_PROPERTY);
        olingo4endpointPropertyNames.add(ENDPOINT_HTTP_HEADERS_PROPERTY);
        olingo4endpointPropertyNames.add(SERVICE_URI_PROPERTY);
        olingo4endpointPropertyNames.add(FILTER_ALREADY_SEEN);

         
        if (!(READ_METHOD.equals(methodName) || DELETE_METHOD.equals(methodName) || UREAD_METHOD.equals(methodName))
                && inBody == null) {
            inBody = DATA_PROPERTY;
        }
        createProxy();
    }

    public OperationResult<List<String>> getResult() {
        try {
            Stat statistics = new Stat();

            List<String> children = connection.getChildren(node, true, statistics);
            if (LOG.isDebugEnabled()) {
                if (LOG.isTraceEnabled()) {
                    LOG.trace(format("Received children from '%s' path with statistics '%s'", node, statistics));
                } else {
                    LOG.debug(format("Received children from '%s' path ", node));
                }
            }
            return new OperationResult<>(children, statistics);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return new OperationResult<>(e);
        } catch (Exception e) {
            return new OperationResult<>(e);
        }
    }

    public Object unmarshal(final Exchange exchange, final InputStream inputStream) throws Exception {
        if (usingIterator) {
            ZipIterator zipIterator = new ZipIterator(exchange, inputStream);
            zipIterator.setAllowEmptyDirectory(allowEmptyDirectory);
            return zipIterator;
        } else {
            BufferedInputStream bis = new BufferedInputStream(inputStream);
            ZipArchiveInputStream zis = new ArchiveStreamFactory()
                    .createArchiveInputStream(ArchiveStreamFactory.ZIP, bis);
            OutputStreamBuilder osb = OutputStreamBuilder.withExchange(exchange);

            try {
                ZipArchiveEntry entry = zis.getNextEntry();
                if (entry != null) {
                    exchange.getMessage().setHeader(FILE_NAME, entry.getName());
                    IOHelper.copy(zis, osb, IOHelper.DEFAULT_BUFFER_SIZE, false, maxDecompressedSize);
                } else {
                    throw new IllegalStateException("Unable to unzip the file, it may be corrupted.");
                }

                entry = zis.getNextEntry();
                if (entry != null) {
                    throw new IllegalStateException("Zip file has more than 1 entry.");
                }

                return osb.build();
            } finally {
                IOHelper.close(osb, zis, bis);
            }
        }
    }

    public Exchange add(CamelContext camelContext, String key, Exchange oldExchange, Exchange newExchange)
            throws OptimisticLockingException {
        if (!optimistic) {
            throw new UnsupportedOperationException();
        }
        LOG.trace("Adding an Exchange with ID {} for key {} in an optimistic manner.", newExchange.getExchangeId(), key);
        if (oldExchange == null) {
            DefaultExchangeHolder holder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            final DefaultExchangeHolder misbehaviorHolder = cache.putIfAbsent(key, holder);
            if (misbehaviorHolder != null) {
                Exchange misbehaviorEx = unmarshallExchange(camelContext, misbehaviorHolder);
                LOG.error(
                        "Optimistic locking failed for exchange with key {}: IMap#putIfAbsend returned Exchange with ID {}, while it's expected no exchanges to be returned",
                        key, misbehaviorEx != null ? misbehaviorEx.getExchangeId() : "<null>");
                throw new OptimisticLockingException();
            }
        } else {
            DefaultExchangeHolder oldHolder = DefaultExchangeHolder.marshal(oldExchange, true, allowSerializedHeaders);
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            if (!cache.replace(key, oldHolder, newHolder)) {
                LOG.error(
                        "Optimistic locking failed for exchange with key {}: IMap#replace returned no Exchanges, while it's expected to replace one",
                        key);
                throw new OptimisticLockingException();
            }
        }
        LOG.trace("Added an Exchange with ID {} for key {} in optimistic manner.", newExchange.getExchangeId(), key);
        return oldExchange;
    }

            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                List<ReportInstance> reportInstances = null;
                if (response != null) {
                    try {
                        reportInstances = unmarshalResponse(response, request, TypeReferences.REPORT_INSTANCE_LIST_TYPE);
                    } catch (SalesforceException e) {
                        ex = e;
                    }
                }
                callback.onResponse(reportInstances, headers, ex);
            }

    public String getDataFormatName() {
        if ("Csv".equals(type)) {
            return "bindyCsv";
        } else if ("Fixed".equals(type)) {
            return "bindyFixed";
        } else {
            return "bindyKvp";
        }
    }

    protected Message doNext() {
        if (parent == null) {
            parent = getNextElement();
        }
        Message answer = parent;
        parent = null;
        currentEntry = null;

        if (first && answer == null) {
            throw new IllegalStateException("Unable to unzip the file, it may be corrupted.");
        }

        first = false;
        checkNullAnswer(answer);

        return answer;
    }

        public void fromApp(Message message, SessionID sessionID)
                throws FieldNotFound, IncorrectDataFormat, IncorrectTagValue, UnsupportedMessageType {
            try {
                dispatch(QuickfixjEventCategory.AppMessageReceived, sessionID, message);
            } catch (RuntimeException e) {
                throw e;
            } catch (Exception e) {
                rethrowIfType(e, FieldNotFound.class);
                rethrowIfType(e, IncorrectDataFormat.class);
                rethrowIfType(e, IncorrectTagValue.class);
                rethrowIfType(e, UnsupportedMessageType.class);
                throw new DispatcherException(e);
            }
        }

    public static List<RestServiceDetails> parseRestService(
            JavaClassSource clazz, String fullyQualifiedFileName,
            boolean includeInlinedRouteBuilders) {

        List<MethodSource<JavaClassSource>> methods = findAllConfigureMethods(clazz, includeInlinedRouteBuilders);

        CamelJavaRestDslParserHelper parser = new CamelJavaRestDslParserHelper();
        List<RestServiceDetails> list = new ArrayList<>();
        for (MethodSource<JavaClassSource> configureMethod : methods) {
             
            List<RestServiceDetails> details = parser.parseRestService(clazz, fullyQualifiedFileName, configureMethod);
            list.addAll(details);
        }
         
        Collections.reverse(list);

        return list;
    }

    protected void doStart() throws Exception {
        for (MainListener listener : listeners) {
            listener.beforeStart(this);
        }

        super.doStart();

        getCamelContext().start();

        for (MainListener listener : listeners) {
            listener.afterStart(this);
        }
    }

    public DynamicRouterEndpoint(final String uri, final DynamicRouterComponent component,
                                 final DynamicRouterConfiguration configuration,
                                 final Supplier<DynamicRouterProcessorFactory> processorFactorySupplier,
                                 final Supplier<DynamicRouterProducerFactory> producerFactorySupplier,
                                 final BiFunction<CamelContext, Expression, RecipientList> recipientListSupplier,
                                 final DynamicRouterFilterService filterService) {
        super(uri, component);
        this.channel = configuration.getChannel();
        this.configuration = configuration;
        this.processorFactorySupplier = processorFactorySupplier;
        this.producerFactorySupplier = producerFactorySupplier;
        this.recipientListSupplier = recipientListSupplier;
        this.configuration.setChannel(channel);
        this.filterService = filterService;
        LOG.debug("Created Dynamic Router endpoint URI: {}", uri);
    }

    private void closeLockFiles() {
        if (leaderLockFile != null) {
            try {
                leaderLockFile.close();
            } catch (Exception ignore) {
                LOGGER.warn("{}", ignore.getMessage(), ignore);
            }
            leaderLockFile = null;
        }

        if (leaderDataFile != null) {
            try {
                leaderDataFile.close();
            } catch (Exception ignore) {
                LOGGER.warn("{}", ignore.getMessage(), ignore);
            }
            leaderDataFile = null;
        }
    }

    public Optional<CamelClusterMember> getLeader() {
        if (leaderSelector == null || isStoppingOrStopped()) {
            return Optional.empty();
        }

        try {
            Participant participant = leaderSelector.getLeader();

            return ObjectHelper.equal(participant.getId(), localMember.getId())
                    ? Optional.of(localMember)
                    : Optional.of(new CuratorClusterMember(participant));
        } catch (KeeperException.NoNodeException e) {
            LOGGER.debug("Failed to get get master because node '{}' does not yet exist (error: '{}')",
                    getFullPath(),
                    e.getMessage());
            return Optional.empty();
        } catch (Exception e) {
            throw new RuntimeCamelException(e);
        }
    }

    public static HealthCheckRepository getHealthCheckRepository(CamelContext context, String id) {
        HealthCheckRepository answer = null;

        HealthCheckRegistry hcr = context.getCamelContextExtension().getContextPlugin(HealthCheckRegistry.class);
        if (hcr != null && hcr.isEnabled()) {
            Optional<HealthCheckRepository> repo = hcr.getRepository(id);
            if (repo.isEmpty()) {
                 
                HealthCheckResolver resolver
                        = context.getCamelContextExtension().getContextPlugin(HealthCheckResolver.class);
                HealthCheckRepository hr = resolver.resolveHealthCheckRepository(id);
                if (hr != null) {
                    repo = Optional.of(hr);
                    hcr.register(hr);
                }
            }
            if (repo.isPresent()) {
                answer = repo.get();
            }
        }
        return answer;
    }

    public ActiveMQQueueEndpoint(String uri, JmsComponent component, String destination,
                                 JmsConfiguration configuration, QueueBrowseStrategy queueBrowseStrategy) {
        super(uri, component, destination, false, configuration);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    protected void doStop() throws Exception {
        super.doStop();

        LOG.debug("Stopping OpenShift DeploymentConfigs Consumer");
        if (executor != null) {
            KubernetesHelper.close(deploymentsWatcher, deploymentsWatcher::getWatch);

            if (getEndpoint() != null && getEndpoint().getCamelContext() != null) {
                getEndpoint().getCamelContext().getExecutorServiceManager().shutdownNow(executor);
            } else {
                executor.shutdownNow();
            }
        }
        executor = null;
    }

    public Exchange create(Endpoint fromEndpoint, ExchangePattern exchangePattern) {
        Exchange answer = pool.poll();
        if (answer == null) {
             
            answer = DefaultPooledExchange.newFromEndpoint(fromEndpoint, exchangePattern);
            if (statisticsEnabled) {
                statistics.created.increment();
            }
        } else {
            if (statisticsEnabled) {
                statistics.acquired.increment();
            }
        }

         
        ((ResetableClock) answer.getClock()).reset();
        return answer;
    }

    public Processor createProcessor() throws Exception {
        String key = parseString(definition.getName());
        Expression nameExpr;
        if (LanguageSupport.hasSimpleFunction(key)) {
            nameExpr = camelContext.resolveLanguage("simple").createExpression(key);
        } else {
            nameExpr = camelContext.resolveLanguage("constant").createExpression(key);
        }
        nameExpr.init(camelContext);

        String toKey = parseString(definition.getToName());
        Expression toNameExpr = null;
        if (toKey != null) {
            if (LanguageSupport.hasSimpleFunction(toKey)) {
                toNameExpr = camelContext.resolveLanguage("simple").createExpression(toKey);
            } else {
                toNameExpr = camelContext.resolveLanguage("constant").createExpression(toKey);
            }
            toNameExpr.init(camelContext);
        }

        Class<?> typeClass = parse(Class.class, or(definition.getTypeClass(), parseString(definition.getType())));
        String charset = validateCharset(parseString(definition.getCharset()));
        boolean mandatory = true;
        if (definition.getMandatory() != null) {
            mandatory = parseBoolean(definition.getMandatory(), true);
        }
        ConvertHeaderProcessor answer
                = new ConvertHeaderProcessor(key, nameExpr, toKey, toNameExpr, typeClass, charset, mandatory);
        answer.setDisabled(isDisabled(camelContext, definition));
        return answer;
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
         
        if (remaining.startsWith("DEFAULT/")) {
            remaining = remaining.substring(8);
        }
        final String[] pathSegments = remaining.split("/", -1);
        final String methodName = pathSegments[0];

        if (pathSegments.length > 1) {
            final StringBuilder resourcePath = new StringBuilder();
            for (int i = 1; i < pathSegments.length; i++) {
                resourcePath.append(pathSegments[i]);
                if (i < (pathSegments.length - 1)) {
                    resourcePath.append('/');
                }
            }
             
            parameters.put(Olingo2Endpoint.RESOURCE_PATH_PROPERTY, resourcePath.toString());
        }

        final Olingo2Configuration endpointConfiguration = createEndpointConfiguration(Olingo2ApiName.DEFAULT);
        final Endpoint endpoint = createEndpoint(uri, methodName, Olingo2ApiName.DEFAULT, endpointConfiguration);

         
        setProperties(endpoint, parameters);

        return endpoint;
    }

    public Map<String, Object> endpointLenientProperties(Exchange exchange, String uri) throws Exception {
        Map<String, Object> properties;
         
        Map<String, Object> map = URISupport.parseQuery(URISupport.extractQuery(uri));
        if (map != null && !map.isEmpty()) {
            if (resolveRawParameterValues()) {
                 
                 
                 
                RawParameterHelper.resolveRawParameterValues(exchange.getContext(), map);
            }
            properties = new LinkedHashMap<>();
            map.forEach((k, v) -> {
                 
                 
                boolean accept = !knownProperties.contains(k);
                if (accept && !knownPrefixes.isEmpty()) {
                    accept = knownPrefixes.values().stream().noneMatch(k::startsWith);
                }
                if (accept) {
                    properties.put(k, v.toString());
                }
            });
        } else {
            properties = map;
        }
        return properties;
    }

    private XPathFunction createSimpleFunction() {
        return new XPathFunction() {
            @SuppressWarnings("rawtypes")
            public Object evaluate(List list) throws XPathFunctionException {
                if (!list.isEmpty()) {
                    Object value = list.get(0);
                    if (value != null) {
                        String exprText = exchange.get().getContext().getTypeConverter().convertTo(String.class, value);
                        Language simple = exchange.get().getContext().resolveLanguage("simple");
                        Expression exp = simple.createExpression(exprText);
                        return exp.evaluate(exchange.get(), Object.class);
                    }
                }
                return null;
            }
        };
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        StripeConfiguration configuration = new StripeConfiguration();
        configuration.setOperation(remaining);

        if (apiKey != null) {
            configuration.setApiKey(apiKey);
        }
        if (apiBase != null) {
            configuration.setApiBase(apiBase);
        }

        StripeEndpoint endpoint = new StripeEndpoint(uri, this, configuration);
        setProperties(endpoint, parameters);

        return endpoint;
    }

    public Integer extractTokenCount(String chunk) throws JsonProcessingException {
        if (chunk == null || chunk.trim().isEmpty()) {
            return null;
        }
        JsonNode node = MAPPER.readTree(chunk);
        JsonNode type = node.get("type");

        if (type != null && "message_delta".equals(type.asText())) {
            JsonNode usage = node.get("usage");
            if (usage != null) {
                JsonNode outputTokens = usage.get("output_tokens");
                return outputTokens != null && !outputTokens.isNull() ? outputTokens.asInt() : null;
            }
        }
        return null;
    }

    protected Integer doDumpCall() throws Exception {
         
        tableHelper = new MessageTableHelper();
        tableHelper.setPretty(pretty);
        tableHelper.setLoggingColor(loggingColor);

        Map<Long, Pid> pids = new LinkedHashMap<>();

         
        updatePids(pids);
        if (!pids.isEmpty()) {
             
            if (find != null) {
                findAnsi = Ansi.ansi().fg(Ansi.Color.BLACK).bg(Ansi.Color.YELLOW).a("$0").reset().toString();
                for (int i = 0; i < find.length; i++) {
                    String f = find[i];
                    f = Pattern.quote(f);
                    find[i] = f;
                }
            }
            if (grep != null) {
                findAnsi = Ansi.ansi().fg(Ansi.Color.BLACK).bg(Ansi.Color.YELLOW).a("$0").reset().toString();
                for (int i = 0; i < grep.length; i++) {
                    String f = grep[i];
                    f = Pattern.quote(f);
                    grep[i] = f;
                }
            }
            Date limit = null;
            if (since != null) {
                long millis;
                if (StringHelper.isDigit(since)) {
                     
                    millis = TimePatternConverter.toMilliSeconds(since) * 1000;
                } else {
                    millis = TimePatternConverter.toMilliSeconds(since);
                }
                limit = new Date(System.currentTimeMillis() - millis);
            }
             
            if (tail != 0) {
                tailReceiveFiles(pids, tail);
                dumpReceiveFiles(pids, tail, limit);
            }
        }

        if (follow) {
            boolean waitMessage = true;
            final AtomicBoolean running = new AtomicBoolean(true);
            Thread t = new Thread(() -> {
                waitUserTask = new CommandHelper.ReadConsoleTask(() -> running.set(false));
                waitUserTask.run();
            }, "WaitForUser");
            t.start();
            boolean more = true;
            boolean init = true;
            StopWatch watch = new StopWatch();
            do {
                if (pids.isEmpty()) {
                    if (waitMessage) {
                        if (!"json".equals(output)) {
                            printer().println("Waiting for messages ...");
                        }
                        waitMessage = false;
                    }
                    Thread.sleep(500);
                    updatePids(pids);
                } else {
                    waitMessage = true;
                    if (watch.taken() > 500) {
                         
                        updatePids(pids);
                        watch.restart();
                    }
                    int lines = readReceiveFiles(pids);
                    if (lines > 0) {
                        more = dumpReceiveFiles(pids, 0, null);
                        init = false;
                    } else if (lines == 0) {
                        if (init) {
                            if (!"json".equals(output)) {
                                printer().println("Waiting for messages ...");
                            }
                            init = false;
                        }
                        Thread.sleep(100);
                    } else {
                        break;
                    }
                }
            } while (more && running.get());
        }

        return 0;
    }

    public void onPutAsync(Message message) {
        final BasicCache<Object, Object> cache = getCache(message);
        final Object key = message.getHeader(InfinispanConstants.KEY, configuration::getKey);
        final Object value = message.getHeader(InfinispanConstants.VALUE, configuration::getValue);
        final CompletableFuture<Object> result;

        if (hasLifespan(message)) {
            long lifespan = message.getHeader(InfinispanConstants.LIFESPAN_TIME, long.class);
            TimeUnit timeUnit = message.getHeader(InfinispanConstants.LIFESPAN_TIME_UNIT, TimeUnit.class);

            if (hasMaxIdleTime(message)) {
                long maxIdle = message.getHeader(InfinispanConstants.MAX_IDLE_TIME, long.class);
                TimeUnit maxIdleTimeUnit = message.getHeader(InfinispanConstants.MAX_IDLE_TIME_UNIT, TimeUnit.class);

                result = cache.putAsync(key, value, lifespan, timeUnit, maxIdle, maxIdleTimeUnit);
            } else {
                result = cache.putAsync(key, value, lifespan, timeUnit);
            }
        } else {
            result = cache.putAsync(key, value);
        }

        setResult(message, result);
    }

    public void setupJacksonXml(
            CamelContext camelContext, RestConfiguration config,
            String type, Class<?> typeClass, String outType, Class<?> outTypeClass,
            DataFormat xml, DataFormat outXml)
            throws Exception {
         
        PropertyConfigurer configurer = PluginHelper.getConfigurerResolver(camelContext)
                .resolvePropertyConfigurer("jacksonXml-dataformat-configurer", camelContext);
        if (configurer == null) {
            throw new IllegalStateException("Cannot find configurer for dataformat: jacksonXml");
        }

         
         
         

        PropertyBindingSupport.Builder builder = PropertyBindingSupport.build()
                .withCamelContext(camelContext)
                .withConfigurer(configurer)
                .withTarget(xml);

        final String typeName = getTypeName(type, typeClass);
        if (typeName != null) {
            builder.withProperty("unmarshalTypeName", typeName);
        }

        setAdditionalConfiguration(config, "xml.in.", builder);
        builder.bind();

         
         
         

        PropertyBindingSupport.Builder outBuilder = PropertyBindingSupport.build()
                .withCamelContext(camelContext)
                .withConfigurer(configurer)
                .withTarget(outXml);

        final String outTypeName = getOutTypeName(outType, outTypeClass, typeName);

        if (outTypeName != null) {
            outBuilder.withProperty("unmarshalTypeName", outTypeName);
        }

        setAdditionalConfiguration(config, "xml.out.", outBuilder);
        outBuilder.bind();
    }

    private ProcessingResult manualCommitResultProcessing(
            KafkaConsumer camelKafkaConsumer, Exchange exchange, java.util.List<Exchange> exchanges) {
        try {
            processor.process(exchange);
        } catch (Exception e) {
            exchange.setException(e);
        }
        if (exchange.getException() != null) {
            ExceptionHandler exceptionHandler = camelKafkaConsumer.getExceptionHandler();
            boolean breakOnErrorHit = processException(exchange, exceptionHandler);
            if (breakOnErrorHit) {
                 
                Exchange firstExchange = exchanges.isEmpty() ? null : exchanges.get(0);
                if (firstExchange != null) {
                    Message message = firstExchange.getMessage();
                    String topic = (String) message.getHeader(KafkaConstants.TOPIC);
                    Integer partition = (Integer) message.getHeader(KafkaConstants.PARTITION);
                    Long offset = (Long) message.getHeader(KafkaConstants.OFFSET);
                    if (topic != null && partition != null && offset != null) {
                        return new ProcessingResult(true, true, topic, partition, offset);
                    }
                }
                 
                return new ProcessingResult(true, true);
            }
        }
        return ProcessingResult.newUnprocessed();
    }

    public void search(String soslQuery, Map<String, List<String>> headers, ResponseCallback callback) {
        try {

            String encodedQuery = urlEncode(soslQuery);
            final Request get = getRequest(HttpMethod.GET, versionUrl() + "search/?q=" + encodedQuery, headers);

             
            setAccessToken(get);

            doHttpRequest(get, new DelegatingClientCallback(callback));

        } catch (UnsupportedEncodingException e) {
            String msg = "Unexpected error: " + e.getMessage();
            callback.onResponse(null, Collections.emptyMap(), new SalesforceException(msg, e));
        }
    }

        public void presence(PubNub pubnub, PNPresenceEventResult presence) {
            Exchange exchange = createExchange(true);
            Message inmessage = exchange.getIn();
            inmessage.setBody(presence);
            inmessage.setHeader(TIMETOKEN, presence.getTimetoken());
            inmessage.setHeader(CHANNEL, presence.getChannel());
            inmessage.setHeader(Exchange.MESSAGE_TIMESTAMP, presence.getTimetoken());
            try {
                getProcessor().process(exchange);
            } catch (Exception e) {
                getExceptionHandler().handleException("Error processing exchange", e);
            }
        }

    public void process(Exchange exchange) throws Exception {
        Object payload = exchange.getMessage().getBody();
        if (payload == null) {
            return;
        }

        ProtobufSchema answer = computeIfAbsent(exchange);

        if (answer != null) {
            exchange.setProperty(SchemaHelper.CONTENT_SCHEMA, answer);
            exchange.setProperty(SchemaHelper.CONTENT_SCHEMA_TYPE, SchemaType.PROTOBUF.type());
            exchange.setProperty(SchemaHelper.CONTENT_CLASS, SchemaHelper.resolveContentClass(exchange, this.contentClass));
        }
    }

    protected void doInit() throws Exception {
        super.doInit();

         
        if (getEndpoint().isSharedEntityManager()) {
            this.entityManager = SharedEntityManagerCreator.createSharedEntityManager(entityManagerFactory);
        } else {
            this.entityManager = entityManagerFactory.createEntityManager();
        }
        LOG.trace("Created EntityManager {} on {}", entityManager, this);
    }

    private static List<String> gatherEnums(UriPath path, Class<?> fieldTypeElement) {
        if (!Strings.isNullOrEmpty(path.enums())) {
            String[] values = path.enums().split(",");
            return Stream.of(values).map(String::trim).toList();
        } else if (fieldTypeElement.isEnum()) {
            return doGatherFromEnum(fieldTypeElement);
        }

        return null;
    }

    protected LongHistogram getInstrument(String name, String description) {
        LongHistogram timer = timers.get(name);
        if (timer == null) {
            synchronized (lock) {
                timer = timers.get(name);
                if (timer == null) {
                    Meter meter = getEndpoint().getMeter();
                    LongHistogramBuilder builder = meter.histogramBuilder(name).ofLongs();
                    if (description != null) {
                        builder.setDescription(description);
                    }
                    builder.setUnit(getEndpoint().getUnit().name().toLowerCase());
                    timer = builder.build();
                    timers.put(name, timer);
                }
            }
        }
        return timer;
    }

private int jjMoveStringLiteralDfa4_0(long old0, long active0){
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_0(2, old0);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(3, active0);
      return 4;
   }
   switch(curChar)
   {
      case 84:
         return jjMoveStringLiteralDfa5_0(active0, 0x8L);
      default :
         break;
   }
   return jjStartNfa_0(3, active0);
}

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.caffeine.cache.CaffeineCacheProducer target = (org.apache.camel.component.caffeine.cache.CaffeineCacheProducer) obj;
        switch (key) {
        case "as_map":
        case "AS_MAP": target.onAsMap(exchange.getMessage()); return null;
        case "cleanup":
        case "CLEANUP": target.onCleanUp(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "invalidate":
        case "INVALIDATE": target.onInvalidate(exchange.getMessage()); return null;
        case "invalidate_all":
        case "INVALIDATE_ALL": target.onInvalidateAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        default: return null;
        }
    }

        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            if (obj == null) {
                return false;

            }
            if (getClass() != obj.getClass()) {
                return false;
            }
            ProcessorNameAndMessageId other = (ProcessorNameAndMessageId) obj;
            if (messageId == null) {
                if (other.messageId != null) {
                    return false;
                }
            } else if (!messageId.equals(other.messageId)) {
                return false;
            }
            if (processorName == null) {
                if (other.processorName != null) {
                    return false;
                }
            } else if (!processorName.equals(other.processorName)) {
                return false;
            }
            return true;
        }

    public BigDecimal getBigDecimal(final int index) {
        Object returnable = this.get(index);
        if (returnable instanceof BigDecimal) {
             
        } else if (returnable instanceof Number) {
             
            returnable = new BigDecimal(returnable.toString());
        } else if (returnable instanceof String) {
             
            returnable = new BigDecimal((String) returnable);
        }
        return (BigDecimal) returnable;
    }

    public void performList(final Exchange exchange, AsyncCallback callback) {
        Message message = exchange.getMessage();
        Map<String, Object> headers = message.getHeaders();
        String subscribeChannel = (String) headers.getOrDefault(CONTROL_SUBSCRIBE_CHANNEL, configuration.getSubscribeChannel());
        try {
            String filters = dynamicRouterControlService.getSubscriptionsForChannel(subscribeChannel);
            message.setBody(filters, String.class);
        } catch (Exception e) {
            exchange.setException(e);
        } finally {
            callback.done(false);
        }
    }

    private void getCustomModel(Exchange exchange) {
        TextToSpeech tts = getEndpoint().getTtsClient();
        if (tts == null) {
            throw new IllegalStateException("TTS client not initialized");
        }

        String modelId = exchange.getIn().getHeader(WatsonTextToSpeechConstants.MODEL_ID, String.class);
        if (modelId == null) {
            modelId = exchange.getIn().getBody(String.class);
        }

        if (modelId == null || modelId.isBlank()) {
            throw new IllegalArgumentException("Model ID must be specified");
        }

        LOG.trace("Getting custom model: {}", modelId);

        GetCustomModelOptions options = new GetCustomModelOptions.Builder()
                .customizationId(modelId)
                .build();

        CustomModel customModel = tts.getCustomModel(options).execute().getResult();

        Message message = getMessageForResponse(exchange);
        message.setBody(customModel);
    }

    protected void encode(ChannelHandlerContext ctx, AddressedEnvelope<Object, InetSocketAddress> msg, List<Object> out)
            throws Exception {
        if (msg.content() instanceof ByteBuf) {
            ByteBuf payload = (ByteBuf) msg.content();
             
            DatagramPacket dp = new DatagramPacket(payload.retain(), msg.recipient());
            out.add(dp);
        } else {
            LOG.debug("Ignoring message content as it is not an io.netty.buffer.ByteBuf instance.");
        }
    }

    private static String detectMimeTypeFromExtension(String fileName) {
        String lowerName = fileName.toLowerCase();

         
        if (lowerName.endsWith(".png")) {
            return "image/png";
        } else if (lowerName.endsWith(".jpg") || lowerName.endsWith(".jpeg")) {
            return "image/jpeg";
        } else if (lowerName.endsWith(".gif")) {
            return "image/gif";
        } else if (lowerName.endsWith(".webp")) {
            return "image/webp";
        } else if (lowerName.endsWith(".bmp")) {
            return "image/bmp";
        } else if (lowerName.endsWith(".tiff") || lowerName.endsWith(".tif")) {
            return "image/tiff";
        } else if (lowerName.endsWith(".svg")) {
            return "image/svg+xml";
        }
         
        else if (lowerName.endsWith(".mp4")) {
            return "video/mp4";
        } else if (lowerName.endsWith(".webm")) {
            return "video/webm";
        } else if (lowerName.endsWith(".mov")) {
            return "video/quicktime";
        } else if (lowerName.endsWith(".mkv")) {
            return "video/x-matroska";
        } else if (lowerName.endsWith(".avi")) {
            return "video/x-msvideo";
        }
         
        else if (lowerName.endsWith(".wav")) {
            return "audio/wav";
        } else if (lowerName.endsWith(".mp3")) {
            return "audio/mpeg";
        } else if (lowerName.endsWith(".ogg")) {
            return "audio/ogg";
        } else if (lowerName.endsWith(".m4a")) {
            return "audio/mp4";
        } else if (lowerName.endsWith(".flac")) {
            return "audio/flac";
        }
         
        else if (lowerName.endsWith(".pdf")) {
            return "application/pdf";
        }
         
        else if (lowerName.endsWith(".txt")) {
            return "text/plain";
        } else if (lowerName.endsWith(".csv")) {
            return "text/csv";
        } else if (lowerName.endsWith(".html") || lowerName.endsWith(".htm")) {
            return "text/html";
        } else if (lowerName.endsWith(".md")) {
            return "text/markdown";
        } else if (lowerName.endsWith(".xml")) {
            return "text/xml";
        } else if (lowerName.endsWith(".json")) {
            return "application/json";
        }

        LOG.warn("Could not detect MIME type from file extension: {}. Please set the CamelLangChain4jAgentMediaType header.",
                fileName);
        throw new IllegalArgumentException(
                "Cannot determine MIME type for file: " + fileName
                                           + ". Please set the CamelLangChain4jAgentMediaType header.");
    }

    protected String doCallText(Map<String, Object> options) {
        StringBuilder sb = new StringBuilder();

        if (propertiesFunction != null) {
            sb.append("Kubernetes Secrets Cluster:");
            KubernetesClient client = propertiesFunction.getClient();
            if (client != null && client.getMasterUrl() != null) {
                sb.append(String.format("\n    Master Url: %s", client.getMasterUrl().toString()));
                sb.append("\n    Login: OAuth Token");
            }
            KubernetesVaultConfiguration kubernetes
                    = getCamelContext().getVaultConfiguration().getKubernetesVaultConfiguration();
            if (kubernetes != null) {
                sb.append(String.format("\n    Refresh Enabled: %s", kubernetes.isRefreshEnabled()));
            }
            if (secretsRefreshTask != null) {
                Instant start = secretsRefreshTask.getStartingTime();
                String s = start != null ? TimeUtils.printSince(start.toEpochMilli()) : "none";
                sb.append(String.format("\n    Running Since: %s", s));
            }
            List<String> sorted = new ArrayList<>();
            if (kubernetes != null) {
                sb.append("\n\nSecrets in use:");

                sorted = new ArrayList<>(List.of(kubernetes.getSecrets().split(",")));
                Collections.sort(sorted);
            }

            for (String sec : sorted) {
                sb.append(String.format("\n    %s", sec));
            }
        }

        return sb.toString();
    }

    public String getServiceUrl() {
        if (!getConfiguration().isOverrideEndpoint()) {
            if (ObjectHelper.isNotEmpty(getConfiguration().getRegion())) {
                return getConfiguration().getRegion();
            }
        } else if (ObjectHelper.isNotEmpty(getConfiguration().getUriEndpointOverride())) {
            return getConfiguration().getUriEndpointOverride();
        }
        return null;
    }

  final public OutParameter OutParameter() throws ParseException {Token sqlTypeToken;
     String outValueMapKey;
     Integer scale = null;
     String typeName = null;
    jj_consume_token(2);
    sqlTypeToken = ParameterSqlType();
    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
    case SCALE:{
      scale = Scale();
      break;
      }
    default:
      jj_la1[6] = jj_gen;
      ;
    }
    jj_consume_token(1);
    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
    case PARAMETER_NAME:{
      typeName = ParameterName();
      jj_consume_token(1);
      break;
      }
    default:
      jj_la1[7] = jj_gen;
      ;
    }
    outValueMapKey = OutHeader();
{if ("" != null) return new OutParameter(ParseHelper.parseSqlType(sqlTypeToken, classResolver), outValueMapKey, scale, typeName);}
    throw new Error("Missing return statement in function");
}

    public boolean process(Exchange exchange, AsyncCallback callback) {
        try {
            MicrometerObservationSpanAdapter camelSpan = (MicrometerObservationSpanAdapter) ActiveSpanManager.getSpan(exchange);
            Observation observation = camelSpan.getMicrometerObservation();
            if (observation != null) {
                String tag = expression.evaluate(exchange, String.class);
                observation.highCardinalityKeyValue(attributeName, tag);
            } else {
                LOG.warn("Micrometer Observation: Cannot find managed span for exchange: {}", exchange);
            }
        } catch (Exception e) {
            exchange.setException(e);
        } finally {
             
            callback.done(true);
        }

        return true;
    }

    protected void doStop() throws Exception {
        connectorsLock.lock();
        try {
            for (ConnectorRef connectorRef : connectors.values()) {
                connectorRef.connector.stop();
            }
            connectors.clear();
        } finally {
            connectorsLock.unlock();
        }

        super.doStop();
    }

    public static JsonObject asJsonObject(DataFormatModel model) {
        JsonObject obj = new JsonObject();
        baseToJson(model, obj);
        artifactToJson(model, obj);

        obj.put("modelName", model.getModelName());
        obj.put("modelJavaType", model.getModelJavaType());
        obj.entrySet().removeIf(e -> e.getValue() == null);
        JsonObject wrapper = new JsonObject();
        wrapper.put("dataformat", obj);
        wrapper.put("properties", asJsonObject(model.getOptions()));
        return wrapper;
    }

    private Object handleCharges(Exchange exchange, String method) throws Exception {
        switch (method) {
            case StripeConstants.METHOD_CREATE:
                return Charge.create(getParametersFromBody(exchange));
            case StripeConstants.METHOD_RETRIEVE:
                String id = exchange.getIn().getHeader(StripeConstants.OBJECT_ID, String.class);
                return Charge.retrieve(id);
            case StripeConstants.METHOD_UPDATE:
                String chargeId = exchange.getIn().getHeader(StripeConstants.OBJECT_ID, String.class);
                Charge charge = Charge.retrieve(chargeId);
                return charge.update(getParametersFromBody(exchange));
            case StripeConstants.METHOD_LIST:
                return Charge.list(getParametersFromBody(exchange));
            case StripeConstants.METHOD_CAPTURE:
                String captureId = exchange.getIn().getHeader(StripeConstants.OBJECT_ID, String.class);
                Charge captureCharge = Charge.retrieve(captureId);
                return captureCharge.capture(getParametersFromBody(exchange));
            default:
                throw new IllegalArgumentException("Unsupported method for charges: " + method);
        }
    }

    private static void parseApplicationPkcs7MimeEnvelopedEntity(
            HttpMessage message, InputStream is, AS2SessionInputBuffer inBuffer, ContentType contentType,
            String contentTransferEncoding)
            throws HttpException {
        ApplicationPkcs7MimeEnvelopedDataEntity applicationPkcs7MimeEnvelopedDataEntity = null;

        ObjectHelper.notNull(message, "message");
        ObjectHelper.notNull(inBuffer, "inBuffer");

        HttpEntity entity = ObjectHelper.notNull(EntityUtils.getMessageEntity(message), "message entity");

        if (entity instanceof ApplicationPkcs7MimeCompressedDataEntity) {
             
            return;
        }

        Args.check(entity.isStreaming(), "Message entity can not be parsed: entity is not streaming");

        try {

            applicationPkcs7MimeEnvelopedDataEntity
                    = parseApplicationPkcs7MimeEnvelopedDataEntityBody(inBuffer, is, null, contentType,
                            contentTransferEncoding);
            applicationPkcs7MimeEnvelopedDataEntity.setMainBody(true);

            EntityUtils.setMessageEntity(message, applicationPkcs7MimeEnvelopedDataEntity);

        } catch (Exception e) {
            throw new HttpException("Failed to parse entity content", e);
        }
    }

    private void setResult(Message message, boolean success, Object result, Object oldValue) {
        message.setHeader(CaffeineConstants.ACTION_SUCCEEDED, success);
        message.setHeader(CaffeineConstants.ACTION_HAS_RESULT, oldValue != null || result != null);

        if (oldValue != null) {
            message.setHeader(CaffeineConstants.OLD_VALUE, oldValue);
        }
        if (result != null) {
            message.setBody(result);
        }
    }

    protected Connector getSocketConnector(Server server, JettyHttpEndpoint endpoint) {
        Connector answer = null;
        if (socketConnectors != null) {
            answer = socketConnectors.get(endpoint.getPort());
        }
        if (answer == null) {
            answer = createConnector(server, endpoint);
        }
        return answer;
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        String[] parts = remaining.split(":");

        if (parts.length < 2) {
            throw new IllegalArgumentException("Google BigQuery Endpoint format \"projectId:datasetId:tableName\"");
        }

        GoogleBigQueryConfiguration conf = configuration != null ? configuration.copy() : new GoogleBigQueryConfiguration();
        conf.parseRemaining(remaining);

        GoogleBigQueryEndpoint endpoint = new GoogleBigQueryEndpoint(uri, this, conf);
        setProperties(endpoint, parameters);
        return endpoint;
    }

    private Element findEncryptedDataElement(Element element) {
         
        if (EncryptionConstants._TAG_ENCRYPTEDDATA.equals(element.getLocalName())
                && EncryptionConstants.EncryptionSpecNS.equals(element.getNamespaceURI())) {
            return element;
        }

         
        Node child = element.getFirstChild();
        while (child != null) {
            if (child.getNodeType() == Node.ELEMENT_NODE) {
                Element childElement = (Element) child;
                if (EncryptionConstants._TAG_ENCRYPTEDDATA.equals(childElement.getLocalName())
                        && EncryptionConstants.EncryptionSpecNS.equals(childElement.getNamespaceURI())) {
                    return childElement;
                }
            }
            child = child.getNextSibling();
        }

        return null;
    }

    private String getAlgorithmName(String algorithm) {
        try {
            return PQCSignatureAlgorithms.valueOf(algorithm).getAlgorithm();
        } catch (IllegalArgumentException e1) {
            try {
                return PQCKeyEncapsulationAlgorithms.valueOf(algorithm).getAlgorithm();
            } catch (IllegalArgumentException e2) {
                return algorithm;
            }
        }
    }

    public void createJob(JobInfo request, Map<String, List<String>> headers, final JobInfoResponseCallback callback) {
         
        sanitizeJobRequest(request);

        final Request post = getRequest(HttpMethod.POST, jobUrl(null), headers);
        try {
            marshalRequest(objectFactory.createJobInfo(request), post, APPLICATION_XML_UTF8);
        } catch (Exception e) {
            callback.onResponse(null, Collections.emptyMap(), new SalesforceException(e));
            return;
        }

         
        doHttpRequest(post, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                JobInfo value = null;
                if (response != null) {
                    try {
                        value = unmarshalResponse(response, post, JobInfo.class);
                    } catch (SalesforceException e) {
                        ex = e;
                    }
                }
                callback.onResponse(value, headers, ex);
            }
        });
    }

    protected TBase loadDefaultInstance(final String className, final CamelContext context)
            throws CamelException, ClassNotFoundException {
        Class<?> instanceClass = context.getClassResolver().resolveMandatoryClass(className);
        if (TBase.class.isAssignableFrom(instanceClass)) {
            try {
                return (TBase) instanceClass.getDeclaredConstructor().newInstance();
            } catch (final Exception ex) {
                throw new CamelException(
                        "Cannot set the defaultInstance of ThriftDataFormat with " + className + ", caused by " + ex);
            }
        } else {
            throw new CamelException(
                    "Cannot set the defaultInstance of ThriftDataFormat with " + className
                                     + ", as the class is not a subClass of org.apache.thrift.TBase");
        }
    }

    protected void autoConfigure(String key) {
        var config = new org.apache.camel.util.OrderedLocationProperties();
        config.putAll("camel-main", camelContext.getPropertiesComponent().loadProperties());

         
        InputStream is = getClass().getResourceAsStream("/auto-configure/" + key + ".java");
        if (is != null) {
            try {
                 
                DependencyDownloader downloader = camelContext.hasService(DependencyDownloader.class);
                 
                downloader.downloadHiddenDependency("org.apache.camel", "camel-joor", camelContext.getVersion());
                 
                String script = IOHelper.loadText(is);
                Language lan = camelContext.resolveLanguage("java");
                Expression exp = lan.createExpression(script);
                Object out = exp.evaluate(new DefaultExchange(camelContext), Object.class);
                if (ObjectHelper.isNotEmpty(out)) {
                    LOG.info("{}", out);
                }
            } catch (Exception e) {
                throw RuntimeCamelException.wrapRuntimeException(e);
            } finally {
                IOHelper.close(is);
            }
        }
    }

    private void createKVSecret(Exchange exchange) {
        KVSecretPrototype.Builder kvSecretResourceBuilder = new KVSecretPrototype.Builder();
        if (ObjectHelper.isNotEmpty(exchange.getMessage().getHeader(IBMSecretsManagerConstants.SECRET_NAME, String.class))) {
            kvSecretResourceBuilder
                    .name(exchange.getMessage().getHeader(IBMSecretsManagerConstants.SECRET_NAME, String.class));
        } else {
            throw new IllegalArgumentException(
                    "Secret Name must be specified. Set the header '" + IBMSecretsManagerConstants.SECRET_NAME
                                               + "' with the desired secret name.");
        }
        Map<String, Object> data = exchange.getMessage().getBody(Map.class);
        if (ObjectHelper.isEmpty(data)) {
            throw new IllegalArgumentException(
                    "Secret data must be provided as a Map in the message body for createKVSecret operation.");
        }
        kvSecretResourceBuilder.data(data);
        kvSecretResourceBuilder.secretType(KVSecretPrototype.SecretType.KV);
        KVSecretPrototype kvSecretResource = kvSecretResourceBuilder.build();

        CreateSecretOptions createSecretOptions = new CreateSecretOptions.Builder()
                .secretPrototype(kvSecretResource)
                .build();
        Response<Secret> createResp = getEndpoint().getSecretManager().createSecret(createSecretOptions).execute();

        exchange.getMessage().setBody(createResp.getResult().getId());
    }

    private static DataLakeServiceClient createDataLakeServiceClientWithClientSecret(
            final DataLakeConfiguration configuration) {
        ClientSecretCredential clientSecretCredential = configuration.getClientSecretCredential();
        if (clientSecretCredential == null) {
            LOG.trace("Using client id, client secret, tenant id to instantiate service client");
            clientSecretCredential = new ClientSecretCredentialBuilder()
                    .clientId(configuration.getClientId())
                    .clientSecret(configuration.getClientSecret())
                    .tenantId(configuration.getTenantId())
                    .build();
        } else {
            LOG.trace("Using configured client secret instance to instantiate service client");
        }

        return new DataLakeServiceClientBuilder()
                .credential(clientSecretCredential)
                .endpoint(buildAzureUri(configuration))
                .buildClient();
    }

    private void doUpdate(Exchange exchange, SqlSession session) {
        Object result;
        Object in = getInput(exchange);
        if (in != null) {
            Iterator<?> iter;
            if (in instanceof Map) {
                 
                iter = Collections.singletonList(in).iterator();
            } else {
                iter = ObjectHelper.createIterator(in);
            }
            while (iter.hasNext()) {
                Object value = iter.next();
                LOG.trace("Updating: {} using statement: {}", value, statement);
                result = session.update(statement, value);
                doProcessResult(exchange, result, session);
            }
        } else {
            LOG.trace("Updating using statement: {}", statement);
            result = session.update(statement);
            doProcessResult(exchange, result, session);
        }
    }

    public FunctionGraphClient initClient() {
        if (functionGraphClient != null) {
            return functionGraphClient;
        }

         
        BasicCredentials auth = new BasicCredentials()
                .withAk(getServiceKeys() != null
                        ? getServiceKeys().getAccessKey()
                        : getAccessKey())
                .withSk(getServiceKeys() != null
                        ? getServiceKeys().getSecretKey()
                        : getSecretKey())
                .withProjectId(getProjectId());

         
        HttpConfig httpConfig = HttpConfig.getDefaultHttpConfig();
        httpConfig.withIgnoreSSLVerification(isIgnoreSslVerification());
        if (ObjectHelper.isNotEmpty(getProxyHost())
                && ObjectHelper.isNotEmpty(getProxyPort())) {
            httpConfig.withProxyHost(getProxyHost())
                    .withProxyPort(getProxyPort());

            if (ObjectHelper.isNotEmpty(getProxyUser())) {
                httpConfig.withProxyUsername(getProxyUser());
                if (ObjectHelper.isNotEmpty(getProxyPassword())) {
                    httpConfig.withProxyPassword(getProxyPassword());
                }
            }
        }

         
        if (ObjectHelper.isNotEmpty(getEndpoint())) {
            return FunctionGraphClient.newBuilder()
                    .withCredential(auth)
                    .withHttpConfig(httpConfig)
                    .withEndpoint(getEndpoint())
                    .build();
        } else {
            return FunctionGraphClient.newBuilder()
                    .withCredential(auth)
                    .withHttpConfig(httpConfig)
                    .withRegion(FunctionGraphRegion.valueOf(getRegion()))
                    .build();
        }
    }

    public FluentProducerTemplate withExchangeProperties(Map<String, Object> properties) {
        DefaultFluentProducerTemplate clone = checkCloned();

        if (clone.processorSupplier != null) {
            throw new IllegalArgumentException(
                    "Cannot use both withExchangeProperties and withProcessor with FluentProducerTemplate");
        }

        Map<String, Object> map = clone.exchangeProperties;
        if (map == null) {
            map = new LinkedHashMap<>();
            clone.exchangeProperties = map;
        }
        map.putAll(properties);
        return clone;
    }

    protected void doListEventsByLabel(Exchange exchange) {
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        Map<String, String> labels = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_EVENTS_LABELS, Map.class);
        EventList eventList;

        if (ObjectHelper.isEmpty(labels)) {
            LOG.error("Get events by labels require specify a labels set");
            throw new IllegalArgumentException("Get events by labels require specify a labels set");
        }

        if (ObjectHelper.isEmpty(namespace)) {
            eventList = getEndpoint().getKubernetesClient().events().v1().events().inAnyNamespace().withLabels(labels).list();
        } else {
            eventList = getEndpoint().getKubernetesClient().events().v1().events().inNamespace(namespace).withLabels(labels)
                    .list();
        }

        prepareOutboundMessage(exchange, eventList.getItems());
    }

    private ZipArchiveEntry getNextEntry() throws IOException {
        ZipArchiveEntry entry;

        while ((entry = zipInputStream.getNextEntry()) != null) {
            if (!entry.isDirectory()) {
                return entry;
            } else {
                if (allowEmptyDirectory) {
                    return entry;
                }
            }
        }

        return null;
    }

    protected String doCallText(Map<String, Object> options) {
        StringBuilder sb = new StringBuilder();

        if (propertiesFunction != null) {
            sb.append("Kubernetes Secrets Cluster:");
            KubernetesClient client = propertiesFunction.getClient();
            if (client != null && client.getMasterUrl() != null) {
                sb.append(String.format("\n    Master Url: %s", client.getMasterUrl().toString()));
                sb.append("\n    Login: OAuth Token");
            }
            KubernetesVaultConfiguration kubernetes
                    = getCamelContext().getVaultConfiguration().getKubernetesVaultConfiguration();
            if (kubernetes != null) {
                sb.append(String.format("\n    Refresh Enabled: %s", kubernetes.isRefreshEnabled()));
            }
            if (secretsRefreshTask != null) {
                Instant start = secretsRefreshTask.getStartingTime();
                String s = start != null ? TimeUtils.printSince(start.toEpochMilli()) : "none";
                sb.append(String.format("\n    Running Since: %s", s));
            }
            List<String> sorted = new ArrayList<>();
            if (kubernetes != null) {
                sb.append("\n\nSecrets in use:");

                sorted = new ArrayList<>(List.of(kubernetes.getSecrets().split(",")));
                Collections.sort(sorted);
            }

            for (String sec : sorted) {
                sb.append(String.format("\n    %s", sec));
            }
        }

        return sb.toString();
    }

    protected boolean isMatched(Supplier<GenericFile<SftpRemoteFile>> file, String doneFileName, SftpRemoteFile[] files) {
        String onlyName = FileUtil.stripPath(doneFileName);

        for (SftpRemoteFile f : files) {
            if (f.getFilename().equals(onlyName)) {
                return true;
            }
        }

        LOG.trace("Done file: {} does not exist", doneFileName);
        return false;
    }

    private void untagDroplet(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
        if (ObjectHelper.isEmpty(exchange.getIn().getHeader(DigitalOceanHeaders.NAME))) {
            throw new IllegalArgumentException(DigitalOceanHeaders.NAME + " must be specified");
        }

        ArrayList<Resource> resources = new ArrayList<>(1);
        resources.add(new Resource(dropletId.toString(), ResourceType.DROPLET));
        Response response = getEndpoint().getDigitalOceanClient().untagResources(dropletId.toString(), resources);
        LOG.trace("Untag Droplet {} : [{}] ", dropletId, response);
        exchange.getMessage().setBody(response);
    }

    private <REQ, RES> void executeOperation(
            Exchange exchange,
            Class<REQ> requestClass,
            Function<REQ, RES> pojoExecutor,
            Supplier<RES> headerExecutor,
            String operationName,
            BiConsumer<RES, Message> responseProcessor)
            throws InvalidPayloadException {

        RES result;
        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (requestClass.isInstance(payload)) {
                try {
                    result = pojoExecutor.apply(requestClass.cast(payload));
                } catch (AwsServiceException ase) {
                    LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                    throw ase;
                }
            } else {
                throw new IllegalArgumentException(
                        String.format("Expected body of type %s but was %s",
                                requestClass.getName(),
                                payload != null ? payload.getClass().getName() : "null"));
            }
        } else {
            try {
                result = headerExecutor.get();
            } catch (AwsServiceException ase) {
                LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                throw ase;
            }
        }
        Message message = getMessageForResponse(exchange);
        message.setBody(result);
        if (responseProcessor != null) {
            responseProcessor.accept(result, message);
        }
    }

    protected void doStart() throws Exception {
        ObjectHelper.notNull(camelContext, "camelContext");
        ObjectHelper.notNull(configuration, "configuration");

        if (cache != null) {
            cacheManager = new JCacheManager<>(cache);
        } else {
            cacheManager = JCacheHelper.createManager(getCamelContext(), configuration);
            cache = cacheManager.getCache();
        }
    }

    protected JsonObject doCallJson(Map<String, Object> options) {
        JsonObject root = new JsonObject();

        List<ResilienceProcessor> cbs = new ArrayList<>();
        for (Route route : getCamelContext().getRoutes()) {
            List<Processor> list = route.filter("*");
            for (Processor p : list) {
                if (p instanceof ResilienceProcessor) {
                    cbs.add((ResilienceProcessor) p);
                }
            }
        }
         
        cbs.sort(Comparator.comparing(ResilienceProcessor::getId));

        final List<JsonObject> list = new ArrayList<>();
        for (ResilienceProcessor cb : cbs) {
            JsonObject jo = new JsonObject();
            jo.put("id", cb.getId());
            jo.put("routeId", cb.getRouteId());
            jo.put("state", cb.getCircuitBreakerState());
            jo.put("bufferedCalls", cb.getNumberOfBufferedCalls());
            jo.put("successfulCalls", cb.getNumberOfSuccessfulCalls());
            jo.put("failedCalls", cb.getNumberOfFailedCalls());
            jo.put("notPermittedCalls", cb.getNumberOfNotPermittedCalls());
            jo.put("failureRate", cb.getFailureRate());
            list.add(jo);
        }
        root.put("circuitBreakers", list);

        return root;
    }

    private FTPFile[] getFtpFiles(String dir) {
        FTPFile[] files = null;
        try {
            LOG.trace("Polling directory: {}", dir);
            if (isUseList()) {
                files = listFiles(dir);
            } else {
                files = pollNamedFile();
            }
        } catch (GenericFileOperationFailedException e) {
            if (ignoreCannotRetrieveFile(null, null, e)) {
                LOG.debug("Cannot list files in directory {} due directory does not exist or file permission error.", dir);
            } else {
                throw e;
            }
        }
        return files;
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        try {
            MicrometerObservationSpanAdapter camelSpan = (MicrometerObservationSpanAdapter) ActiveSpanManager.getSpan(exchange);
            if (camelSpan != null) {
                String item = expression.evaluate(exchange, String.class);
                camelSpan.setCorrelationContextItem(baggageName, item);
            } else {
                LOG.warn("Micrometer Observation: Cannot find managed span for exchange: {}", exchange);
            }
        } catch (Exception e) {
            exchange.setException(e);
        } finally {
             
            callback.done(true);
        }

        return true;
    }

    public static HttpString createMethod(Exchange exchange, UndertowEndpoint endpoint, boolean hasPayload)
            throws URISyntaxException {
         
         
        String queryString = exchange.getIn().getHeader(UndertowConstants.HTTP_QUERY, String.class);
         
        String uriString = exchange.getIn().getHeader(UndertowConstants.HTTP_URI, String.class);
         
        try {
            uriString = exchange.getContext().resolvePropertyPlaceholders(uriString);
        } catch (Exception e) {
            throw new RuntimeExchangeException("Cannot resolve property placeholders with uri: " + uriString, exchange, e);
        }
        if (uriString != null) {
            URI uri = new URI(uriString);
            queryString = uri.getQuery();
        }
        if (queryString == null) {
            queryString = endpoint.getHttpURI().getRawQuery();
        }

         
        HttpString answer;
        String m = exchange.getIn().getHeader(UndertowConstants.HTTP_METHOD, String.class);
        if (m != null) {
             
             
            m = m.toUpperCase();
            answer = new HttpString(m);
        } else if (queryString != null) {
             
            answer = Methods.GET;
        } else {
             
            answer = hasPayload ? Methods.POST : Methods.GET;
        }

        return answer;
    }

    protected Set<FieldInfo> fields(ClassInfo ci) {
        Set<FieldInfo> fields = new TreeSet<>(Comparator.comparing(FieldInfo::name));

        ClassInfo current = ci;
        while (current != null) {
            fields.addAll(current.fields());

            DotName superName = current.superName();
            if (superName == null) {
                break;
            }

            current = view.getClassByName(superName);
        }

        return fields;
    }

    private Integer doCallLocal(boolean autoDump) throws Exception {
        AtomicReference<KameletMain> ref = new AtomicReference<>();
        Run run = new Run(this.getMain()) {
            @Override
            protected int runKameletMain(KameletMain main) throws Exception {
                ref.set(main);
                return super.runKameletMain(main);
            }
        };
        run.empty = true;
        run.propertiesFiles = propertiesFiles;
        run.property = property;

         
        final CountDownLatch latch = new CountDownLatch(1);
        this.pid = ProcessHandle.current().pid();
        Path outputFile = writeReceiveData();
        Thread t = new Thread("CamelJBangSendStatus") {
            @Override
            public void run() {
                try {
                    if (!showStatus(outputFile)) {
                         
                        return;
                    }
                    if (autoDump) {
                        doDumpCall();
                    }
                } catch (Exception e) {
                     
                } finally {
                    latch.countDown();
                     
                    KameletMain main = ref.get();
                    if (main != null) {
                        main.completed();
                    }
                }
            }
        };
         
        t.start();

        Integer exit = run.call();
        latch.await();

        return exit;
    }

    public void setPrivateKeyName(String privateKeyName) {
        if (context != null && privateKeyName != null) {
            PrivateKey pk = context.getRegistry().lookupByNameAndType(privateKeyName, PrivateKey.class);
            if (pk != null) {
                setPrivateKey(pk);
            }
        }
        if (privateKeyName != null) {
            this.privateKeyName = privateKeyName;
        }
    }

    private void getVectors(S3VectorsClient client, Exchange exchange) {
        Message message = exchange.getIn();
        String vectorBucketName = determineVectorBucketName(exchange);
        String vectorIndexName = determineVectorIndexName(exchange);

         
        Object vectorIdsObj = message.getHeader(AWS2S3VectorsConstants.VECTOR_ID);
        if (vectorIdsObj == null) {
            vectorIdsObj = message.getBody();
        }

        List<String> vectorIds = convertToStringList(vectorIdsObj);

         
        GetVectorsRequest request = GetVectorsRequest.builder()
                .vectorBucketName(vectorBucketName)
                .indexName(vectorIndexName)
                .keys(vectorIds)
                .build();

        LOG.trace("Getting vectors [{}] from bucket [{}] index [{}]", vectorIds, vectorBucketName, vectorIndexName);
        GetVectorsResponse response = client.getVectors(request);
        LOG.trace("Get vectors response: {}", response);

        message.setBody(response.vectors());
    }

    public void setCertificateName(String certificateName) {
        if (context != null && certificateName != null) {
            Certificate certificate = context.getRegistry().lookupByNameAndType(certificateName, Certificate.class);
            if (certificate != null) {
                setCertificate(certificate);
            }
        }
        if (certificateName != null) {
            this.certificateName = certificateName;
        }
    }

    private String getContent(Row r) {
        StringJoiner sj = new StringJoiner("   ");
        if (r.consumes != null || r.produces != null) {
            if (r.consumes != null) {
                sj.add("accept: " + r.consumes);
            }
            if (r.produces != null) {
                sj.add("produces: " + r.produces);
            }
        }
        if (sj.length() > 0) {
            return sj.toString();
        }
        return "";
    }

    private void doCreateOrUpdateDeployment(
            Exchange exchange, String operationName, Function<Resource<Deployment>, Deployment> operation) {
        String deploymentName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_DEPLOYMENT_NAME, String.class);
        String namespaceName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        DeploymentSpec deSpec
                = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_DEPLOYMENT_SPEC, DeploymentSpec.class);
        if (ObjectHelper.isEmpty(deploymentName)) {
            LOG.error("{} a specific Deployment require specify a Deployment name", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific Deployment require specify a pod name", operationName));
        }
        if (ObjectHelper.isEmpty(namespaceName)) {
            LOG.error("{} a specific Deployment require specify a namespace name", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific Deployment require specify a namespace name", operationName));
        }
        if (ObjectHelper.isEmpty(deSpec)) {
            LOG.error("{} a specific Deployment require specify a Deployment spec bean", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific Deployment require specify a Deployment spec bean", operationName));
        }
        Map<String, String> labels = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_DEPLOYMENTS_LABELS, Map.class);
        Map<String, String> annotations
                = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_DEPLOYMENTS_ANNOTATIONS, Map.class);
        DeploymentBuilder deploymentCreating;
        if (ObjectHelper.isEmpty(annotations)) {
            deploymentCreating = new DeploymentBuilder().withNewMetadata().withName(deploymentName).withLabels(labels)
                    .endMetadata().withSpec(deSpec);
        } else {
            deploymentCreating = new DeploymentBuilder().withNewMetadata().withName(deploymentName).withLabels(labels)
                    .withAnnotations(annotations)
                    .endMetadata().withSpec(deSpec);
        }
        Deployment deployment
                = operation.apply(getEndpoint().getKubernetesClient().apps().deployments().inNamespace(namespaceName)
                        .resource(deploymentCreating.build()));

        prepareOutboundMessage(exchange, deployment);
    }

    public StaticServiceCallServiceDiscoveryConfiguration servers(String servers) {
        if (ObjectHelper.isNotEmpty(servers)) {
            String[] parts = servers.split(",");

            if (this.servers == null) {
                this.servers = new ArrayList<>();
            }

            this.servers.addAll(Arrays.asList(parts));
        }

        return this;
    }

    public void setLoggingSizeLimit(int loggingSizeLimit) {
        this.loggingSizeLimit = loggingSizeLimit;
        if (loggingFeature != null) {
            getFeatures().remove(loggingFeature);
            if (loggingSizeLimit > 0) {
                loggingFeature = new LoggingFeature();
                loggingFeature.setLimit(getLoggingSizeLimit());
            } else {
                loggingFeature = new LoggingFeature();
            }
            getFeatures().add(loggingFeature);
        }
    }

    protected void printSource(List<Row> rows) {
        for (Row row : rows) {
            printer().println();
            if (!raw) {
                printer().printf("Source: %s%n", row.location);
                printer().println("--------------------------------------------------------------------------------");
            }
            for (int i = 0; i < row.code.size(); i++) {
                Code code = row.code.get(i);
                String c = Jsoner.unescape(code.code);
                if (raw) {
                    printer().printf("%s%n", c);
                } else {
                    if (code.line != -1) {
                        printer().printf("%4d: %s%n", code.line, c);
                    } else {
                        printer().printf("      %s%n", c);
                    }
                }
            }
            printer().println();
        }
    }

    public TabularData listEndpoints() {
        try {
            TabularData answer = new TabularDataSupport(CamelOpenMBeanTypes.listEndpointsTabularType());
            Collection<Endpoint> endpoints = endpointRegistry.values();
            for (Endpoint endpoint : endpoints) {
                CompositeType ct = CamelOpenMBeanTypes.listEndpointsCompositeType();
                String url = endpoint.getEndpointUri();
                if (sanitize) {
                    url = URISupport.sanitizeUri(url);
                }

                boolean fromStatic = endpointRegistry.isStatic(url);
                boolean fromDynamic = endpointRegistry.isDynamic(url);

                CompositeData data = new CompositeDataSupport(
                        ct, new String[] { "url", "static", "dynamic" }, new Object[] { url, fromStatic, fromDynamic });
                answer.put(data);
            }
            return answer;
        } catch (Exception e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        }
    }

    public static Object deserializeJavaObjectFromStream(InputStream is) throws ClassNotFoundException, IOException {
        if (is == null) {
            return null;
        }

        Object answer = null;
        ObjectInputStream ois = new ObjectInputStream(is);
        try {
            answer = ois.readObject();
        } finally {
            IOHelper.close(ois);
        }

        return answer;
    }

    public Processor createProcessor() throws Exception {
        ObjectHelper.notNull(definition.getName(), "propertyName", this);
        Expression expr = createExpression(definition.getExpression());
        Expression nameExpr;
        String key = parseString(definition.getName());
        if (LanguageSupport.hasSimpleFunction(key)) {
            nameExpr = camelContext.resolveLanguage("simple").createExpression(key);
        } else {
            nameExpr = camelContext.resolveLanguage("constant").createExpression(key);
        }
        nameExpr.init(camelContext);

        SetPropertyProcessor answer = new SetPropertyProcessor(nameExpr, expr);
        answer.setDisabled(isDisabled(camelContext, definition));
        return answer;
    }

    private void loadProperties(Map<String, Object> properties, Optional<?> optional, PropertyConfigurer configurer) {
        BeanIntrospection beanIntrospection = PluginHelper.getBeanIntrospection(camelContext);
        optional.ifPresent(bean -> {
            if (configurer instanceof ExtendedPropertyConfigurerGetter) {
                ExtendedPropertyConfigurerGetter getter = (ExtendedPropertyConfigurerGetter) configurer;
                Map<String, Object> types = getter.getAllOptions(bean);
                types.forEach((k, t) -> {
                    Object value = getter.getOptionValue(bean, k, true);
                    if (value != null) {
                        properties.put(k, value);
                    }
                });
            } else {
                 
                beanIntrospection.getProperties(bean, properties, null, false);
            }
        });
    }

    public Producer createProducer() throws Exception {
        switch (getSubsystem()) {
            case NovaConstants.NOVA_SUBSYSTEM_FLAVORS:
                return new FlavorsProducer(this, createClient());
            case NovaConstants.NOVA_SUBSYSTEM_SERVERS:
                return new ServerProducer(this, createClient());
            case NovaConstants.NOVA_SUBSYSTEM_KEYPAIRS:
                return new KeypairProducer(this, createClient());
            default:
                throw new IllegalArgumentException("Can't create producer with subsystem " + subsystem);
        }
    }

    public MediaSizeName selectMediaSizeNameISO(String size) {
        if (size.equalsIgnoreCase("iso_a0")) {
            mediaSizeName = MediaSizeName.ISO_A0;
        } else if (size.equalsIgnoreCase("iso_a1")) {
            mediaSizeName = MediaSizeName.ISO_A1;
        } else if (size.equalsIgnoreCase("iso_a2")) {
            mediaSizeName = MediaSizeName.ISO_A2;
        } else if (size.equalsIgnoreCase("iso_a3")) {
            mediaSizeName = MediaSizeName.ISO_A3;
        } else if (size.equalsIgnoreCase("iso_a4")) {
            mediaSizeName = MediaSizeName.ISO_A4;
        } else if (size.equalsIgnoreCase("iso_a5")) {
            mediaSizeName = MediaSizeName.ISO_A5;
        } else if (size.equalsIgnoreCase("iso_a6")) {
            mediaSizeName = MediaSizeName.ISO_A6;
        } else if (size.equalsIgnoreCase("iso_a7")) {
            mediaSizeName = MediaSizeName.ISO_A7;
        } else if (size.equalsIgnoreCase("iso_a8")) {
            mediaSizeName = MediaSizeName.ISO_A8;
        } else if (size.equalsIgnoreCase("iso_a9")) {
            mediaSizeName = MediaSizeName.ISO_A9;
        } else if (size.equalsIgnoreCase("iso_a10")) {
            mediaSizeName = MediaSizeName.ISO_A10;
        } else if (size.equalsIgnoreCase("iso_b0")) {
            mediaSizeName = MediaSizeName.ISO_B0;
        } else if (size.equalsIgnoreCase("iso_b1")) {
            mediaSizeName = MediaSizeName.ISO_B1;
        } else if (size.equalsIgnoreCase("iso_b2")) {
            mediaSizeName = MediaSizeName.ISO_B2;
        } else if (size.equalsIgnoreCase("iso_b3")) {
            mediaSizeName = MediaSizeName.ISO_B3;
        } else if (size.equalsIgnoreCase("iso_b4")) {
            mediaSizeName = MediaSizeName.ISO_B4;
        } else if (size.equalsIgnoreCase("iso_b5")) {
            mediaSizeName = MediaSizeName.ISO_B5;
        } else if (size.equalsIgnoreCase("iso_b6")) {
            mediaSizeName = MediaSizeName.ISO_B6;
        } else if (size.equalsIgnoreCase("iso_b7")) {
            mediaSizeName = MediaSizeName.ISO_B7;
        } else if (size.equalsIgnoreCase("iso_b8")) {
            mediaSizeName = MediaSizeName.ISO_B8;
        } else if (size.equalsIgnoreCase("iso_b9")) {
            mediaSizeName = MediaSizeName.ISO_B9;
        } else if (size.equalsIgnoreCase("iso_b10")) {
            mediaSizeName = MediaSizeName.ISO_B10;
        } else if (size.equalsIgnoreCase("iso_c0")) {
            mediaSizeName = MediaSizeName.ISO_C0;
        } else if (size.equalsIgnoreCase("iso_c1")) {
            mediaSizeName = MediaSizeName.ISO_C1;
        } else if (size.equalsIgnoreCase("iso_c2")) {
            mediaSizeName = MediaSizeName.ISO_C2;
        } else if (size.equalsIgnoreCase("iso_c3")) {
            mediaSizeName = MediaSizeName.ISO_C3;
        } else if (size.equalsIgnoreCase("iso_c4")) {
            mediaSizeName = MediaSizeName.ISO_C4;
        } else if (size.equalsIgnoreCase("iso_c5")) {
            mediaSizeName = MediaSizeName.ISO_C5;
        } else if (size.equalsIgnoreCase("iso_c6")) {
            mediaSizeName = MediaSizeName.ISO_C6;
        }
        return mediaSizeName;
    }

    private void doCreateOrUpdateResourceQuota(
            Exchange exchange, String operationName, Function<Resource<ResourceQuota>, ResourceQuota> operation) {
        String rqName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_RESOURCES_QUOTA_NAME, String.class);
        String namespaceName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        ResourceQuotaSpec rqSpec
                = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_RESOURCE_QUOTA_SPEC, ResourceQuotaSpec.class);
        if (ObjectHelper.isEmpty(rqName)) {
            LOG.error("{} a specific resource quota require specify a resource quota name", operationName);
            throw new IllegalArgumentException(
                    operationName + " a specific resource quota require specify a resource quota name");
        }
        if (ObjectHelper.isEmpty(namespaceName)) {
            LOG.error("{} a specific resource quota require specify a namespace name", operationName);
            throw new IllegalArgumentException(operationName + " a specific resource quota require specify a namespace name");
        }
        if (ObjectHelper.isEmpty(rqSpec)) {
            LOG.error("{} a specific resource quota require specify a resource quota spec bean", operationName);
            throw new IllegalArgumentException(
                    operationName + " a specific resource quota require specify a resource quota spec bean");
        }
        Map<String, String> labels
                = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_RESOURCES_QUOTA_LABELS, Map.class);
        ResourceQuota rqCreating = new ResourceQuotaBuilder().withNewMetadata().withName(rqName).withLabels(labels)
                .endMetadata().withSpec(rqSpec).build();
        ResourceQuota rq
                = operation.apply(
                        getEndpoint().getKubernetesClient().resourceQuotas().inNamespace(namespaceName).resource(rqCreating));

        prepareOutboundMessage(exchange, rq);
    }

    public String resolveStaticUri(Exchange exchange, DynamicAwareEntry entry) throws Exception {
        String destination = parseDestinationName(entry.getUri());
        if (destination != null) {
            String originalDestination = parseDestinationName(entry.getOriginalUri());
            if (!destination.equals(originalDestination)) {
                 
                String answer = entry.getUri();
                answer = StringHelper.replaceFirst(answer, destination, originalDestination);
                return answer;
            }
        }
        return null;
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
         
        if (remaining.startsWith("DEFAULT/")) {
            remaining = remaining.substring(8);
        }
        final String[] pathSegments = remaining.split("/", -1);
        final String methodName = pathSegments[0];

        if (pathSegments.length > 1) {
            final StringBuilder resourcePath = new StringBuilder();
            for (int i = 1; i < pathSegments.length; i++) {
                resourcePath.append(pathSegments[i]);
                if (i < (pathSegments.length - 1)) {
                    resourcePath.append('/');
                }
            }
             
            parameters.put(Olingo4Endpoint.RESOURCE_PATH_PROPERTY, resourcePath.toString());
        }

        final Olingo4Configuration endpointConfiguration = createEndpointConfiguration(Olingo4ApiName.DEFAULT);
        final Endpoint endpoint = createEndpoint(uri, methodName, Olingo4ApiName.DEFAULT, endpointConfiguration);

         
        setProperties(endpoint, parameters);

        return endpoint;
    }

    private String extractPlatform(ProcessHandle ph, JsonObject runtime) {
        String answer = runtime != null ? runtime.getString("platform") : null;
        if ("Camel".equals(answer)) {
             
            String cl = ph.info().commandLine().orElse("");
            if (cl.contains("main.CamelJBang run")) {
                answer = "JBang";
            }
        }
        return answer;
    }

    protected SubmitSm createSubmitSmTemplate(Exchange exchange) {
        Message in = exchange.getIn();
        SubmitSm submitSm = new SubmitSm();

        if (in.getHeaders().containsKey(SmppConstants.DATA_CODING)) {
            submitSm.setDataCoding(in.getHeader(SmppConstants.DATA_CODING, Byte.class));
        } else if (in.getHeaders().containsKey(SmppConstants.ALPHABET)) {
            submitSm.setDataCoding(in.getHeader(SmppConstants.ALPHABET, Byte.class));
        } else {
            submitSm.setDataCoding(config.getDataCoding());
        }

        if (in.getHeaders().containsKey(SmppConstants.DEST_ADDR)) {
            submitSm.setDestAddress(in.getHeader(SmppConstants.DEST_ADDR, String.class));
        } else {
            submitSm.setDestAddress(config.getDestAddr());
        }

        if (in.getHeaders().containsKey(SmppConstants.DEST_ADDR_TON)) {
            submitSm.setDestAddrTon(in.getHeader(SmppConstants.DEST_ADDR_TON, Byte.class));
        } else {
            submitSm.setDestAddrTon(config.getDestAddrTon());
        }

        if (in.getHeaders().containsKey(SmppConstants.DEST_ADDR_NPI)) {
            submitSm.setDestAddrNpi(in.getHeader(SmppConstants.DEST_ADDR_NPI, Byte.class));
        } else {
            submitSm.setDestAddrNpi(config.getDestAddrNpi());
        }

        if (in.getHeaders().containsKey(SmppConstants.SOURCE_ADDR)) {
            submitSm.setSourceAddr(in.getHeader(SmppConstants.SOURCE_ADDR, String.class));
        } else {
            submitSm.setSourceAddr(config.getSourceAddr());
        }

        if (in.getHeaders().containsKey(SmppConstants.SOURCE_ADDR_TON)) {
            submitSm.setSourceAddrTon(in.getHeader(SmppConstants.SOURCE_ADDR_TON, Byte.class));
        } else {
            submitSm.setSourceAddrTon(config.getSourceAddrTon());
        }

        if (in.getHeaders().containsKey(SmppConstants.SOURCE_ADDR_NPI)) {
            submitSm.setSourceAddrNpi(in.getHeader(SmppConstants.SOURCE_ADDR_NPI, Byte.class));
        } else {
            submitSm.setSourceAddrNpi(config.getSourceAddrNpi());
        }

        if (in.getHeaders().containsKey(SmppConstants.SERVICE_TYPE)) {
            submitSm.setServiceType(in.getHeader(SmppConstants.SERVICE_TYPE, String.class));
        } else {
            submitSm.setServiceType(config.getServiceType());
        }

        if (in.getHeaders().containsKey(SmppConstants.PROTOCOL_ID)) {
            submitSm.setProtocolId(in.getHeader(SmppConstants.PROTOCOL_ID, Byte.class));
        } else {
            submitSm.setProtocolId(config.getProtocolId());
        }

        if (in.getHeaders().containsKey(SmppConstants.PRIORITY_FLAG)) {
            submitSm.setPriorityFlag(in.getHeader(SmppConstants.PRIORITY_FLAG, Byte.class));
        } else {
            submitSm.setPriorityFlag(config.getPriorityFlag());
        }

        if (in.getHeaders().containsKey(SmppConstants.SCHEDULE_DELIVERY_TIME)) {
            submitSm.setScheduleDeliveryTime(
                    SmppUtils.formatTime(in.getHeader(SmppConstants.SCHEDULE_DELIVERY_TIME, Date.class)));
        }

        if (in.getHeaders().containsKey(SmppConstants.VALIDITY_PERIOD)) {
            Object validityPeriod = in.getHeader(SmppConstants.VALIDITY_PERIOD);
            if (validityPeriod instanceof String) {
                submitSm.setValidityPeriod((String) validityPeriod);
            } else if (validityPeriod instanceof Date) {
                submitSm.setValidityPeriod(SmppUtils.formatTime((Date) validityPeriod));
            }
        }

        if (in.getHeaders().containsKey(SmppConstants.REPLACE_IF_PRESENT_FLAG)) {
            submitSm.setReplaceIfPresent(in.getHeader(SmppConstants.REPLACE_IF_PRESENT_FLAG, Byte.class));
        } else {
            submitSm.setReplaceIfPresent(config.getReplaceIfPresentFlag());
        }

        submitSm.setEsmClass(new ESMClass().value());

        Map<java.lang.Short, Object> optinalParamater = in.getHeader(SmppConstants.OPTIONAL_PARAMETER, Map.class);
        if (optinalParamater != null) {
            List<OptionalParameter> optParams = createOptionalParametersByCode(optinalParamater);
            submitSm.setOptionalParameters(optParams.toArray(new OptionalParameter[0]));
        } else {
            Map<String, String> optinalParamaters = in.getHeader(SmppConstants.OPTIONAL_PARAMETERS, Map.class);
            if (optinalParamaters != null) {
                List<OptionalParameter> optParams = createOptionalParametersByName(optinalParamaters);
                submitSm.setOptionalParameters(optParams.toArray(new OptionalParameter[0]));
            } else {
                submitSm.setOptionalParameters();
            }
        }

        return submitSm;
    }

    private String getUri(Row r) {
        String u = r.uri;
        if (shortUri) {
            int pos = u.indexOf('?');
            if (pos > 0) {
                u = u.substring(0, pos);
            }
        }
        return u;
    }

    public PullRequestStateProducer(GitHubEndpoint endpoint) throws Exception {
        super(endpoint);

        Registry registry = endpoint.getCamelContext().getRegistry();
        Object service = registry.lookupByName(GitHubConstants.GITHUB_COMMIT_SERVICE);
        if (service != null) {
            LOG.debug("Using CommitService found in registry {}", service.getClass().getCanonicalName());
            commitService = (CommitService) service;
        } else {
            commitService = new CommitService();
        }
        initService(commitService);

        state = endpoint.getState();
        targetUrl = endpoint.getTargetUrl();
    }

    public void marshal(Exchange exchange, Object o, OutputStream outputStream) throws Exception {
        IBaseResource iBaseResource;
        if (!(o instanceof IBaseResource)) {
            iBaseResource = exchange.getContext().getTypeConverter().mandatoryConvertTo(IBaseResource.class, exchange, o);
        } else {
            iBaseResource = (IBaseResource) o;
        }

        IParser parser = getFhirContext().newJsonParser();
        configureParser(parser);
        parser.encodeResourceToWriter(iBaseResource, new OutputStreamWriter(outputStream));

        if (isContentTypeHeader()) {
            exchange.getMessage().setHeader(Exchange.CONTENT_TYPE, parser.getEncoding().getResourceContentTypeNonLegacy());
        }
    }

    public Processor createPreProcessor(Exchange exchange, DynamicAwareEntry entry) throws Exception {
        if (exchange.getMessage().getHeader(KafkaConstants.OVERRIDE_TOPIC) != null) {
            return null;
        }

        final String topicName = parseTopicName(entry.getUri());
        return new Processor() {
            @Override
            public void process(Exchange exchange) throws Exception {
                exchange.getMessage().setHeader(KafkaConstants.OVERRIDE_TOPIC, topicName);
            }
        };
    }

    private void reconnect() throws InterruptedException, IOException, SmackException, XMPPException {
        lock.lock();
        try {
            if (!connection.isConnected()) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("Reconnecting to: {}", XmppEndpoint.getConnectionMessage(connection));
                }
                connection.connect();
            }
        } finally {
            lock.unlock();
        }
    }

    public static Expression trimExpression(final String expression) {
        return new ExpressionAdapter() {
            private Expression exp;

            @Override
            public void init(CamelContext context) {
                if (expression != null) {
                    exp = context.resolveLanguage("simple").createExpression(expression);
                    exp.init(context);
                }
            }

            @Override
            public Object evaluate(Exchange exchange) {
                String value;
                if (exp != null) {
                    value = exp.evaluate(exchange, String.class);
                } else {
                    value = exchange.getMessage().getBody(String.class);
                }
                if (value != null) {
                    value = value.trim();
                }
                return value;
            }

            @Override
            public String toString() {
                if (expression != null) {
                    return "trim(" + expression + ")";
                } else {
                    return "trim()";
                }
            }
        };
    }

    public void interceptProperties(Map<String, Object> properties) {
        Map<String, String> endpointHttpHeaders = (Map<String, String>) properties.get(ENDPOINT_HTTP_HEADERS_PROPERTY);

         
        properties.put(EDM_PROPERTY, apiProxy.getEdm(endpointHttpHeaders));

         
        properties.put(FILTER_ALREADY_SEEN, configuration.isFilterAlreadySeen());

         
        final String keyPredicate = (String) properties.get(KEY_PREDICATE_PROPERTY);
        if (keyPredicate != null) {

             
            properties.compute(RESOURCE_PATH_PROPERTY, (key, resourcePath) -> {
                if (resourcePath == null) {
                    throw new IllegalArgumentException(
                            "Resource path must be provided in endpoint URI, or URI parameter '" + RESOURCE_PATH_PROPERTY
                                                       + "', or exchange header '"
                                                       + Olingo4Constants.PROPERTY_PREFIX + RESOURCE_PATH_PROPERTY + "'");
                }

                 
                return resourcePath + "(" + keyPredicate + ")";
            });
        }

         
        parseQueryParams(properties);
    }

    private void tailTraceFiles(Map<Long, Pid> pids, int tail) throws Exception {
        for (Pid pid : pids.values()) {
            Path file = getTraceFile(pid.pid);
            if (Files.exists(file)) {
                pid.reader = new LineNumberReader(Files.newBufferedReader(file));
                String line;
                if (tail <= 0) {
                    pid.fifo = new ArrayDeque<>();
                } else {
                    pid.fifo = new ArrayBlockingQueue<>(tail);
                }
                do {
                    line = pid.reader.readLine();
                    if (line != null) {
                        while (!pid.fifo.offer(line)) {
                            pid.fifo.poll();
                        }
                    }
                } while (line != null);
            }
        }
    }

    public static JsonObject asJsonObject(PojoBeanModel model) {
        JsonObject obj = new JsonObject();
        baseToJson(model, obj);
        artifactToJson(model, obj);
        obj.entrySet().removeIf(e -> e.getValue() == null);
        JsonObject wrapper = new JsonObject();
        wrapper.put("bean", obj);
        wrapper.put("properties", asJsonObject(model.getOptions()));
        return wrapper;
    }

    private TopContainerCmd executeTopContainerRequest(DockerClient client, Message message) {

        LOGGER.debug("Executing Docker Top Container Request");

        String containerId
                = DockerHelper.getProperty(DockerConstants.DOCKER_CONTAINER_ID, configuration, message, String.class);

        ObjectHelper.notNull(containerId, MISSING_CONTAINER_ID);

        TopContainerCmd topContainerCmd = client.topContainerCmd(containerId);

        String psArgs = DockerHelper.getProperty(DockerConstants.DOCKER_PS_ARGS, configuration, message, String.class);

        if (psArgs != null) {
            topContainerCmd.withPsArgs(psArgs);
        }

        return topContainerCmd;

    }

    protected Set<FieldInfo> fields(ClassInfo ci) {
        Set<FieldInfo> fields = new TreeSet<>(Comparator.comparing(FieldInfo::name));

        ClassInfo current = ci;
        while (current != null) {
            fields.addAll(current.fields());

            DotName superName = current.superName();
            if (superName == null) {
                break;
            }

            current = view.getClassByName(superName);
        }

        return fields;
    }

    public static XQueryBuilder xquery(final InputStream in) {
        return new XQueryBuilder() {
            protected XQueryExpression createQueryExpression(StaticQueryContext staticQueryContext)
                    throws XPathException {
                try {
                    return staticQueryContext.compileQuery(in, ObjectHelper.getDefaultCharacterSet());
                } finally {
                    IOHelper.close(in);
                }
            }
        };
    }

    private List<HttpHost> parseHostAddresses(String ipsString, ElasticsearchConfiguration config) {
        if (ipsString == null || ipsString.isEmpty()) {
            return null;
        }
        List<String> addressesStr = Arrays.asList(ipsString.split(","));
        List<HttpHost> addressesTrAd = new ArrayList<>(addressesStr.size());
        for (String address : addressesStr) {
            String[] split = address.split(":");
            String hostname;
            if (split.length > 0) {
                hostname = split[0];
            } else {
                throw new IllegalArgumentException();
            }
            int port = split.length > 1 ? Integer.parseInt(split[1]) : ElasticsearchConstants.DEFAULT_PORT;
            addressesTrAd.add(new HttpHost(hostname, port, config.isEnableSSL() ? "HTTPS" : "HTTP"));
        }
        return addressesTrAd;
    }

    private Domain messageToDomain(Message message) {
        Domain domain = message.getBody(Domain.class);
        if (domain == null) {
            Map<String, Object> headers = message.getHeaders();
            DomainBuilder builder = Builders.domain();

            StringHelper.notEmpty(message.getHeader(OpenstackConstants.NAME, String.class), "Name");
            builder.name(message.getHeader(OpenstackConstants.NAME, String.class));

            if (headers.containsKey(KeystoneConstants.DESCRIPTION)) {
                builder.description(message.getHeader(KeystoneConstants.DESCRIPTION, String.class));
            }

            domain = builder.build();
        }

        return domain;
    }

    private Expression createIncExpression(CamelContext camelContext, final Expression leftExp) {
        return new Expression() {
            @Override
            public <T> T evaluate(Exchange exchange, Class<T> type) {
                Number num = leftExp.evaluate(exchange, Number.class);
                if (num != null) {
                    long val = num.longValue();
                    val++;

                     
                    Object left = leftExp.evaluate(exchange, Object.class);
                    try {
                        left = camelContext.getTypeConverter().mandatoryConvertTo(left.getClass(), exchange, val);
                    } catch (NoTypeConversionAvailableException e) {
                        throw RuntimeCamelException.wrapRuntimeCamelException(e);
                    }

                     
                    return camelContext.getTypeConverter().convertTo(type, left);
                }
                 
                Exception cause = new CamelExchangeException("Cannot evaluate " + leftExp + " as a number", exchange);
                throw RuntimeCamelException.wrapRuntimeCamelException(cause);
            }

            @Override
            public String toString() {
                return left + operator.toString();
            }
        };
    }

    public String extractCompletionReason(String chunk) throws JsonProcessingException {
        if (chunk == null || chunk.trim().isEmpty()) {
            return null;
        }
        JsonNode node = MAPPER.readTree(chunk);
        JsonNode type = node.get("type");

        if (type != null && "message_delta".equals(type.asText())) {
            JsonNode delta = node.get("delta");
            if (delta != null) {
                JsonNode stopReason = delta.get("stop_reason");
                return stopReason != null && !stopReason.isNull() ? stopReason.asText() : null;
            }
        }
        return null;
    }

    public void setSecureRandomName(String randomName) {
        if (context != null && randomName != null) {
            SecureRandom random = context.getRegistry().lookupByNameAndType(randomName, SecureRandom.class);
            if (keystore != null) {
                setSecureRandom(random);
            }
        }
        if (randomName != null) {
            this.secureRandomName = randomName;
        }
    }

    public <T> T newInstance(Class<T> type, Class<?> factoryClass, String factoryMethod) {
        Class<?> target = factoryClass != null ? factoryClass : type;
        T answer = null;
        try {
             
            Method fm = target.getMethod(factoryMethod);
            if (Modifier.isStatic(fm.getModifiers()) && Modifier.isPublic(fm.getModifiers())
                    && fm.getReturnType() != Void.class) {
                Object obj = fm.invoke(null);
                answer = type.cast(obj);
            }
             
            CamelContextAware.trySetCamelContext(answer, camelContext);
        } catch (Exception e) {
            throw new RuntimeCamelException("Error invoking factory method: " + factoryMethod + " on class: " + target, e);
        }
        return answer;
    }

    public boolean readValue(ASDUAddress asduAddress, InformationObjectAddress ioa) {
        DataModuleContext context = dataModuleContextRef.get();
        if (context == null) {
            LOG.warn("Cannot send read command: not connected or data module not initialized");
            return false;
        }
        try {
            ASDUHeader header = new ASDUHeader(
                    new CauseOfTransmission(StandardCause.REQUEST),
                    asduAddress);
            ReadCommand readCommand = new ReadCommand(header, ioa);

            client.writeCommand(readCommand);

            LOG.debug("Sent read command for ASDU address {} IOA {}", asduAddress, ioa);
            return true;
        } catch (Exception e) {
            LOG.error("Failed to send read command", e);
            return false;
        }
    }

    public JobResponse failJob(JobRequest message) {
        JobResponse resultMessage = new JobResponse();

        try {
            GatewayGrpc.GatewayBlockingStub stub = GatewayGrpc.newBlockingStub(managedChannel);
            GatewayOuterClass.FailJobRequest.Builder builder = GatewayOuterClass.FailJobRequest.newBuilder()
                    .setJobKey(message.getJobKey());
            builder = builder.setRetries(message.getRetries());
            builder = builder.setErrorMessage(message.getFailMessage());
            GatewayOuterClass.FailJobRequest request = builder.build();
            GatewayOuterClass.FailJobResponse failJobResponse = stub.failJob(request);

            resultMessage.setSuccess(true);
        } catch (StatusRuntimeException exception) {
            LOG.error(String.format("Cannot fail Job %s", message.getJobKey()), exception);
            resultMessage.setErrorMessage(exception.getMessage());
            resultMessage.setErrorCode(exception.getStatus().toString());
            resultMessage.setSuccess(false);
        }

        return resultMessage;
    }

    public boolean matches(Exchange exchange) {
        final Object value = evaluate(exchange, Object.class);

        if (value instanceof BooleanNode) {
            return ((BooleanNode) value).asBoolean();
        }
        if (value instanceof Collection) {
            return !((Collection<?>) value).isEmpty();
        }

        return false;
    }

    public int getPort() {
        if (uri.getPort() == -1) {
            if ("cometds".equals(getProtocol())) {
                return 443;
            } else {
                return 80;
            }
        }
        return uri.getPort();
    }

    protected Processor createBodyAndHeaderProcessor(final Object body, final String header, final Object headerValue) {
        return new Processor() {
            public void process(Exchange exchange) {
                Message in = exchange.getIn();
                in.setHeader(header, headerValue);
                in.setBody(body);
            }
        };
    }

    public void setSigPolicyIdDocumentationReferences(List<String> sigPolicyIdDocumentationReferences) {
        if (sigPolicyIdDocumentationReferences == null) {
            throw new IllegalArgumentException("Parameter 'sigPolicyIdDocumentationReferences' is null");
        }
        for (String ref : sigPolicyIdDocumentationReferences) {
            if (ref == null || ref.isEmpty()) {
                throw new IllegalArgumentException(
                        "At least one documentation reference of the signature policy is null or empty");
            }
        }
        this.sigPolicyIdDocumentationReferences = sigPolicyIdDocumentationReferences;
    }

    private ContainerDiffCmd executeDiffContainerRequest(DockerClient client, Message message) {

        LOGGER.debug("Executing Docker Diff Container Request");

        String containerId
                = DockerHelper.getProperty(DockerConstants.DOCKER_CONTAINER_ID, configuration, message, String.class);

        ObjectHelper.notNull(containerId, MISSING_CONTAINER_ID);

        ContainerDiffCmd diffContainerCmd = client.containerDiffCmd(containerId);

        String containerIdDiff
                = DockerHelper.getProperty(DockerConstants.DOCKER_CONTAINER_ID_DIFF, configuration, message, String.class);

        if (containerIdDiff != null) {
            diffContainerCmd.withContainerId(containerIdDiff);
        }

        return diffContainerCmd;

    }

    private Object handlePaymentIntents(Exchange exchange, String method) throws Exception {
        switch (method) {
            case StripeConstants.METHOD_CREATE:
                return PaymentIntent.create(getParametersFromBody(exchange));
            case StripeConstants.METHOD_RETRIEVE:
                String id = exchange.getIn().getHeader(StripeConstants.OBJECT_ID, String.class);
                return PaymentIntent.retrieve(id);
            case StripeConstants.METHOD_UPDATE:
                String piId = exchange.getIn().getHeader(StripeConstants.OBJECT_ID, String.class);
                PaymentIntent pi = PaymentIntent.retrieve(piId);
                return pi.update(getParametersFromBody(exchange));
            case StripeConstants.METHOD_CANCEL:
                String cancelId = exchange.getIn().getHeader(StripeConstants.OBJECT_ID, String.class);
                PaymentIntent cancelPi = PaymentIntent.retrieve(cancelId);
                return cancelPi.cancel();
            case StripeConstants.METHOD_LIST:
                return PaymentIntent.list(getParametersFromBody(exchange));
            default:
                throw new IllegalArgumentException("Unsupported method for payment intents: " + method);
        }
    }

    protected void doStart() throws Exception {
        if (connection == null) {
            try {
                connection = endpoint.createConnection();
            } catch (SmackException e) {
                if (endpoint.isTestConnectionOnStartup()) {
                    throw new RuntimeCamelException(
                            "Could not establish connection to XMPP server: " + endpoint.getConnectionDescription(), e);
                } else {
                    LOG.warn("Could not connect to XMPP server: {} Producer will attempt lazy connection when needed.",
                            e.getMessage());
                }
            }
        }
        super.doStart();
    }

    public void connect(HttpConsumer consumer) throws Exception {
         
        JettyHttpEndpoint endpoint = (JettyHttpEndpoint) consumer.getEndpoint();
        String connectorKey = getConnectorKey(endpoint);

        try {
            CONNECTORS.compute(connectorKey, (cKey, connectorRef) -> {
                try {
                    return connect(consumer, endpoint, cKey, connectorRef);
                } catch (Exception e) {
                    throw new RuntimeCamelException(e);
                }
            });
        } catch (RuntimeCamelException e) {
            throw (Exception) e.getCause();
        }
    }

    protected void doRemove(Exchange exchange, String operation) throws GitAPIException {
        String fileName = null;
        if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(GitConstants.GIT_FILE_NAME))) {
            fileName = exchange.getIn().getHeader(GitConstants.GIT_FILE_NAME, String.class);
        } else {
            throw new IllegalArgumentException("File name must be specified to execute " + operation);
        }
        try {
            if (ObjectHelper.isNotEmpty(endpoint.getBranchName())) {
                git.checkout().setCreateBranch(false).setName(endpoint.getBranchName()).call();
            }
            git.rm().addFilepattern(fileName).call();
        } catch (GitAPIException e) {
            LOG.error("There was an error in Git {} operation", operation);
            throw e;
        }
    }

    private T getNextElement() {
        if (asn1InputStream == null) {
            return null;
        }

        try {
            ASN1Primitive current = getNextEntry();

            if (current != null) {
                return ObjectHelper.cast(clazz, createGenericTypeObject(current));
            } else {
                LOGGER.trace("close asn1InputStream");
                return null;
            }
        } catch (Exception exception) {
            throw new RuntimeCamelException(exception);
        }
    }

    public void execute() throws MojoExecutionException, MojoFailureException {
        if (!mainJsonFile.exists()) {
             
            return;
        }

        File file = new File(docDocDir, "main.adoc");
        boolean exists = file.exists();
        boolean updated;
        try {
            String json = PackageHelper.loadText(mainJsonFile);
            MainModel model = JsonMapper.generateMainModel(json);
            String options = evaluateTemplate("main-options.mvel", model);
            updated = updateOptionsIn(file, "main", options);
        } catch (IOException e) {
            throw new MojoExecutionException("Error preparing main docs", e);
        }

        if (updated) {
            getLog().info("Updated doc file: " + file);
        } else if (exists) {
            if (getLog().isDebugEnabled()) {
                getLog().debug("No changes to doc file: " + file);
            }
        } else {
            getLog().warn("No main doc file: " + file);
        }
    }

    private void updatePids(Map<Long, Row> rows) {
        List<Long> pids = findPids(name);
        ProcessHandle.allProcesses()
                .filter(ph -> pids.contains(ph.pid()))
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                    if (root != null) {
                        Row row = new Row();
                        row.pid = Long.toString(ph.pid());
                        JsonObject context = (JsonObject) root.get("context");
                        if (context == null) {
                            return;
                        }
                        row.name = context.getString("name");
                        if ("CamelJBang".equals(row.name)) {
                            row.name = ProcessHelper.extractName(root, ph);
                        }
                        int len = row.name.length();
                        if (len < NAME_MIN_WIDTH) {
                            len = NAME_MIN_WIDTH;
                        }
                        if (len > NAME_MAX_WIDTH) {
                            len = NAME_MAX_WIDTH;
                        }
                        if (len > nameMaxWidth) {
                            nameMaxWidth = len;
                        }
                        if (!rows.containsKey(ph.pid())) {
                            rows.put(ph.pid(), row);
                        }
                    }
                });

         
        Set<Long> remove = new HashSet<>();
        for (long pid : rows.keySet()) {
            if (!pids.contains(pid)) {
                remove.add(pid);
            }
        }
        for (long pid : remove) {
            rows.remove(pid);
        }
    }

    public BoxFolder.Info getFolderInfo(String folderId, String... fields) {
        try {
            LOG.debug("Getting info for folder(id={})", folderId);
            BoxHelper.notNull(folderId, FOLDER_ID);

            BoxFolder folder = new BoxFolder(boxConnection, folderId);

            if (fields == null || fields.length == 0) {
                return folder.getInfo();
            } else {
                return folder.getInfo(fields);
            }
        } catch (BoxAPIException e) {
            throw new RuntimeCamelException(
                    buildBoxApiErrorMessage(e), e);
        }
    }

    protected DataSet resolveDataSet(Exchange exchange) {
        if (exchange.getIn().getHeader(FlinkConstants.FLINK_DATASET_HEADER) != null) {
            return (DataSet) exchange.getIn().getHeader(FlinkConstants.FLINK_DATASET_HEADER);
        } else if (getEndpoint().getDataSet() != null) {
            return getEndpoint().getDataSet();
        } else {
            throw new IllegalStateException("No DataSet defined");
        }
    }

    private boolean isExcludedHeader(String key) {
        String[] parts = filter.split(",");
        for (String pattern : parts) {
            if (pattern.startsWith("--")) {
                continue;
            }
            if (pattern.startsWith("-header:")) {
                pattern = StringHelper.after(pattern, "-header:");
            }
            if (PatternHelper.matchPattern(key, pattern)) {
                return true;
            }
        }
        return false;
    }

    protected <C> C simple(Exchange exchange, String expression, Class<C> clazz) {
        if (expression != null) {
            Language language = exchange.getContext().resolveLanguage("simple");
            Expression simple = language.createExpression(expression);
            if (simple != null) {
                return simple.evaluate(exchange, clazz);
            }
        }
        return getEndpoint().getCamelContext().getTypeConverter().convertTo(clazz, expression);
    }

        public Destination resolveDestinationName(
                Session session, String destinationName,
                boolean pubSubDomain)
                throws JMSException {
            QueueReplyManager.this.lock.lock();
            try {
                 
                if (destination == null) {
                    destination = delegate.resolveDestinationName(session, destinationName, pubSubDomain);
                    setReplyTo(destination);
                }
            } finally {
                QueueReplyManager.this.lock.unlock();
            }
            return destination;
        }

    public KeyPair rotateKey(String oldKeyId, String newKeyId, String algorithm) throws Exception {
        LOG.info("Rotating key from {} to {}", oldKeyId, newKeyId);

         
        KeyMetadata oldMetadata = getKeyMetadata(oldKeyId);
        if (oldMetadata == null) {
            throw new IllegalArgumentException("Old key not found: " + oldKeyId);
        }

         
        oldMetadata.setStatus(KeyMetadata.KeyStatus.DEPRECATED);
        updateKeyMetadata(oldKeyId, oldMetadata);

         
        KeyPair newKeyPair = generateKeyPair(algorithm, newKeyId);

        LOG.info("Key rotation completed in Vault: {} -> {}", oldKeyId, newKeyId);
        return newKeyPair;
    }

    private void analyzeText(Exchange exchange) {
        NaturalLanguageUnderstanding nlu = getEndpoint().getNluClient();
        if (nlu == null) {
            throw new IllegalStateException("NLU client not initialized. Use service=nlu");
        }

        String text = exchange.getIn().getHeader(WatsonLanguageConstants.TEXT, String.class);
        if (text == null) {
            text = exchange.getIn().getBody(String.class);
        }

        if (text == null || text.isBlank()) {
            throw new IllegalArgumentException("Text to analyze must be specified");
        }

        LOG.trace("Analyzing text with NLU");

        Features features = buildFeatures(exchange);

        AnalyzeOptions options = new AnalyzeOptions.Builder()
                .text(text)
                .features(features)
                .build();

        AnalysisResults result = nlu.analyze(options).execute().getResult();

        Message message = getMessageForResponse(exchange);

         
        message.setBody(result);

         
        if (result.getSentiment() != null && result.getSentiment().getDocument() != null) {
            message.setHeader(WatsonLanguageConstants.SENTIMENT_SCORE, result.getSentiment().getDocument().getScore());
            message.setHeader(WatsonLanguageConstants.SENTIMENT_LABEL, result.getSentiment().getDocument().getLabel());
        }
        if (result.getLanguage() != null) {
            message.setHeader(WatsonLanguageConstants.LANGUAGE, result.getLanguage());
        }
    }

    public ProcessorDefinition<?> after() {
        RouteDefinition route = builder.getOriginalRoute();
        AdviceWithDefinition answer = new AdviceWithDefinition();
        if (id != null) {
            builder.getAdviceWithTasks()
                    .add(AdviceWithTasks.afterById(route, id, answer, selectFirst, selectLast, selectFrom, selectTo, maxDeep));
        } else if (toString != null) {
            builder.getAdviceWithTasks().add(AdviceWithTasks.afterByToString(route, toString, answer, selectFirst, selectLast,
                    selectFrom, selectTo, maxDeep));
        } else if (toUri != null) {
            builder.getAdviceWithTasks().add(
                    AdviceWithTasks.afterByToUri(route, toUri, answer, selectFirst, selectLast, selectFrom, selectTo, maxDeep));
        } else if (type != null) {
            builder.getAdviceWithTasks().add(
                    AdviceWithTasks.afterByType(route, type, answer, selectFirst, selectLast, selectFrom, selectTo, maxDeep));
        }
        return answer;
    }

                    protected void setValues(PreparedStatement ps, LobCreator lobCreator) throws SQLException {
                        int totalParameterIndex = 0;
                        lobCreator.setBlobAsBytes(ps, ++totalParameterIndex, data);
                        ps.setString(++totalParameterIndex, key);
                        ps.setLong(++totalParameterIndex, version);
                        if (storeBodyAsText) {
                            ps.setString(++totalParameterIndex, exchange.getIn().getBody(String.class));
                        }
                        if (hasHeadersToStoreAsText()) {
                            for (String headerName : headersToStoreAsText) {
                                String headerValue = exchange.getIn().getHeader(headerName, String.class);
                                ps.setString(++totalParameterIndex, headerValue);
                            }
                        }
                    }

    protected void doListSecretsByLabels(Exchange exchange) {
        Map<String, String> labels = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_SECRETS_LABELS, Map.class);
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        SecretList secretsList;

        if (ObjectHelper.isEmpty(labels)) {
            LOG.error("Listing Secrets by labels requires specifying labels");
            throw new IllegalArgumentException("Listing Secrets by labels requires specifying labels");
        }

        if (ObjectHelper.isEmpty(namespace)) {
            secretsList = getEndpoint().getKubernetesClient().secrets().inAnyNamespace().withLabels(labels).list();
        } else {
            secretsList = getEndpoint().getKubernetesClient().secrets().inNamespace(namespace).withLabels(labels).list();
        }

        prepareOutboundMessage(exchange, secretsList.getItems());
    }

        XmlSignatureChecker.Input build() {
            return new XmlSignatureChecker.Input() {

                @Override
                public boolean isXmlSchemaValidationExecuted() {
                    return xmlSchemaValidationExecuted;
                }

                @Override
                public int getTotalCountOfSignatures() {
                    return totalCountOfSignatures;
                }

                @Override
                public SignedInfo getSignedInfo() {
                    return signedInfo;
                }

                @Override
                public SignatureValue getSignatureValue() {
                    return signatureValue;
                }

                @Override
                public List<? extends XMLObject> getObjects() {
                    return objects;
                }

                @Override
                public Document getMessageBodyDocument() {
                    return messageBodyDocument;
                }

                @Override
                public Message getMessage() {
                    return message;
                }

                @Override
                public KeyInfo getKeyInfo() {
                    return keyInfo;
                }

                @Override
                public Element getCurrentSignatureElement() {
                    return currentSignatureElement;
                }

                @Override
                public int getCurrentCountOfSignatures() {
                    return currentCountOfSignatures;
                }
            };
        }

    public Integer toInteger(JsonNode node, Exchange exchange) throws Exception {
        if (node instanceof NumericNode) {
            NumericNode nn = (NumericNode) node;
            if (nn.canConvertToInt()) {
                return nn.asInt();
            }
        }
        String text = node.asText();
        return Integer.valueOf(text);
    }

    private static String formatDate(Date date) {
        if (date == null) {
            return null;
        }
        try {
            return new SimpleDateFormat(DATE_TIME_FORMAT).format(date);
        } catch (Exception e) {
            LOG.warn("Unable to format date '{}' using format {}", date, DATE_TIME_FORMAT, e);
        }

        return null;
    }

    private void loadProperties(Map<String, Object> properties, Optional<?> optional, PropertyConfigurer configurer) {
        BeanIntrospection beanIntrospection = PluginHelper.getBeanIntrospection(camelContext);
        optional.ifPresent(bean -> {
            if (configurer instanceof ExtendedPropertyConfigurerGetter) {
                ExtendedPropertyConfigurerGetter getter = (ExtendedPropertyConfigurerGetter) configurer;
                Map<String, Object> types = getter.getAllOptions(bean);
                types.forEach((k, t) -> {
                    Object value = getter.getOptionValue(bean, k, true);
                    if (value != null) {
                        properties.put(k, value);
                    }
                });
            } else {
                 
                beanIntrospection.getProperties(bean, properties, null, false);
            }
        });
    }

    public Processor createErrorHandler(final Processor processor) throws Exception {
        JtaTransactionPolicy transactionPolicy = resolveTransactionPolicy(definition);
        ObjectHelper.notNull(transactionPolicy, "transactionPolicy", this);

         
        RedeliveryPolicy redeliveryPolicy = resolveRedeliveryPolicy(definition, camelContext);
        CamelLogger logger = resolveLogger(definition);
        LoggingLevel rollbackLoggingLevel = resolveRollbackLoggingLevel(definition);

        JtaTransactionErrorHandler answer = new JtaTransactionErrorHandler(
                camelContext, processor, logger,
                getProcessor(definition.getOnRedeliveryProcessor(), definition.getOnRedeliveryRef()),
                redeliveryPolicy,
                transactionPolicy,
                resolveRetryWhilePolicy(definition, camelContext),
                getExecutorService(definition.getExecutorServiceBean(), definition.getExecutorServiceRef()),
                rollbackLoggingLevel,
                getProcessor(definition.getOnExceptionOccurredProcessor(), definition.getOnExceptionOccurredRef()));

         
        configure(answer);
        return answer;
    }

    protected boolean matchSecret(String name) {
        Set<String> set = new HashSet<>();
        if (secrets != null) {
            Collections.addAll(set, secrets.split(","));
        }
        if (propertiesFunction != null) {
            set.addAll(propertiesFunction.getSecrets());
        }

        for (String part : set) {
            boolean result = name.contains(part) || PatternHelper.matchPattern(name, part);
            LOG.trace("Matching secret id: {}={} -> {}", name, part, result);
            if (result) {
                return true;
            }
        }

        return false;
    }

    protected Set<MethodInfo> methods(ClassInfo ci) {
        Set<MethodInfo> methods = new TreeSet<>(Comparator.comparing(MethodInfo::name));

        ClassInfo current = ci;
        while (current != null) {
            methods.addAll(current.methods());

            DotName superName = current.superName();
            if (superName == null) {
                break;
            }

            current = view.getClassByName(superName);
        }

        return methods;
    }

    public ProducerTemplate getObject() throws Exception {
        CamelContext context = getCamelContext();
        if (defaultEndpoint != null) {
            Endpoint endpoint = context.getEndpoint(defaultEndpoint);
            if (endpoint == null) {
                throw new IllegalArgumentException("No endpoint found for URI: " + defaultEndpoint);
            } else {
                template = new DefaultProducerTemplate(context, endpoint);
            }
        } else {
            template = new DefaultProducerTemplate(context);
        }

         
        if (maximumCacheSize != null) {
            template.setMaximumCacheSize(maximumCacheSize);
        }

         
        ServiceHelper.startService(template);
        return template;
    }

    public static Predicate isGreaterThan(final Expression left, final Expression right) {
        return new BinaryPredicateSupport(left, right) {

            protected boolean matches(Exchange exchange, Object leftValue, Object rightValue) {
                if (leftValue == null && rightValue == null) {
                     
                    return false;
                } else if (leftValue == null || rightValue == null) {
                     
                    return false;
                }

                return ObjectHelper.typeCoerceCompare(exchange.getContext().getTypeConverter(), leftValue, rightValue) > 0;
            }

            protected String getOperationText() {
                return ">";
            }
        };
    }

    public Double getDouble(final int index) {
        Object returnable = this.get(index);
        if (returnable == null) {
            return null;
        }
        if (returnable instanceof String) {
             
            returnable = new BigDecimal((String) returnable);
        }
        return ((Number) returnable).doubleValue();
    }

    protected boolean shouldFailOver(Exchange exchange) {
        if (exchange == null) {
            return false;
        }

        boolean answer = false;

        if (exchange.getException() != null) {
            if (exceptions == null || exceptions.isEmpty()) {
                 
                answer = true;
            } else {
                for (Class<?> exception : exceptions) {
                     
                    if (exchange.getException(exception) != null) {
                        answer = true;
                        break;
                    }
                }
            }

            if (answer) {
                 
                statistics.onHandledFailure(exchange.getException());
            }
        }

        if (LOG.isTraceEnabled()) {
            LOG.trace("Should failover: {} for exchangeId: {}", answer, exchange.getExchangeId());
        }

        return answer;
    }

    protected void doStart() throws Exception {
        if (directory == null) {
             
            return;
        }

        File dir = new File(directory);
        if (dir.exists() && dir.isDirectory()) {
            LOG.info("Starting ReloadStrategy to watch directory: {}", dir);

            WatchEvent.Modifier modifier = null;

             
            String os = ObjectHelper.getSystemProperty("os.name", "");
            if (os.toLowerCase(Locale.US).startsWith("mac")) {
                 
                Class<WatchEvent.Modifier> clazz = getCamelContext().getClassResolver()
                        .resolveClass("com.sun.nio.file.SensitivityWatchEventModifier", WatchEvent.Modifier.class);
                if (clazz != null) {
                    WatchEvent.Modifier[] modifiers = clazz.getEnumConstants();
                    for (WatchEvent.Modifier mod : modifiers) {
                        if ("HIGH".equals(mod.name())) {
                            modifier = mod;
                            break;
                        }
                    }
                }
                if (modifier != null) {
                    LOG.info(
                            "On Mac OS X the JDK WatchService is slow by default so enabling SensitivityWatchEventModifier.HIGH as workaround");
                } else {
                    LOG.warn(
                            "On Mac OS X the JDK WatchService is slow and it may take up till 10 seconds to notice file changes");
                }
            }

            try {
                Path path = dir.toPath();
                watcher = path.getFileSystem().newWatchService();
                registerPathToWatcher(modifier, path, watcher);

                task = new WatchFileChangesTask(watcher, path, onChangeEvent);

                executorService
                        = getCamelContext().getExecutorServiceManager().newSingleThreadExecutor(this, "FileWatcherStrategy");
                executorService.submit(task);
            } catch (IOException e) {
                throw RuntimeCamelException.wrapRuntimeCamelException(e);
            }
        }
    }

    private void updatePids(Map<Long, Pid> rows) {
        List<Long> pids;
        if (name != null) {
            pids = findPids(name);
        } else {
            pids = List.of(pid);
        }
        ProcessHandle.allProcesses()
                .filter(ph -> pids.contains(ph.pid()))
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                    if (root != null) {
                        Pid row = new Pid();
                        row.pid = Long.toString(ph.pid());
                        JsonObject context = (JsonObject) root.get("context");
                        if (context == null) {
                            return;
                        }
                        row.name = context.getString("name");
                        if ("CamelJBang".equals(row.name)) {
                            row.name = ProcessHelper.extractName(root, ph);
                        }
                        int len = row.name.length();
                        if (len < NAME_MIN_WIDTH) {
                            len = NAME_MIN_WIDTH;
                        }
                        if (len > NAME_MAX_WIDTH) {
                            len = NAME_MAX_WIDTH;
                        }
                        if (len > nameMaxWidth) {
                            nameMaxWidth = len;
                        }
                        if (!rows.containsKey(ph.pid())) {
                            rows.put(ph.pid(), row);
                        }
                    }
                });

         
        Set<Long> remove = new HashSet<>();
        for (long pid : rows.keySet()) {
            if (!pids.contains(pid)) {
                remove.add(pid);
            }
        }
        for (long pid : remove) {
            rows.remove(pid);
        }
    }

    public WeaviateClient getClient() throws AuthException {
        lock.lock();
        try {
            if (this.client == null) {
                this.client = this.configuration.getClient();
                if (this.client == null) {
                    this.client = createClient();
                }
            }
            return this.client;
        } finally {
            lock.unlock();
        }
    }

        protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
            doBeforeParse(element);
            super.doParse(element, parserContext, builder);

             
            Binder<Node> binder;
            try {
                binder = getJaxbContext().createBinder();
            } catch (JAXBException e) {
                throw new BeanDefinitionStoreException("Failed to create the JAXB binder", e);
            }
            Object value = parseUsingJaxb(element, parserContext, binder);

            if (value instanceof CamelEndpointFactoryBean) {
                CamelEndpointFactoryBean factoryBean = (CamelEndpointFactoryBean) value;
                builder.addPropertyValue("properties", factoryBean.getProperties());
            }
        }

    protected DataSet resolveDataSet(Exchange exchange) {
        if (exchange.getIn().getHeader(FlinkConstants.FLINK_DATASET_HEADER) != null) {
            return (DataSet) exchange.getIn().getHeader(FlinkConstants.FLINK_DATASET_HEADER);
        } else if (getEndpoint().getDataSet() != null) {
            return getEndpoint().getDataSet();
        } else {
            throw new IllegalStateException("No DataSet defined");
        }
    }

    public Object getHeader(String name, Supplier<Object> defaultValueSupplier) {
        Object answer = null;

        if (headers == null) {
             
            headers = createHeaders();
        }

        if (!headers.isEmpty()) {
            answer = headers.get(name);
        }
        return answer != null ? answer : defaultValueSupplier.get();
    }

    public Object unmarshal(final Exchange exchange, final InputStream inputStream) throws Exception {
        InputStream compressedInput = null;

        OutputStreamBuilder osb = OutputStreamBuilder.withExchange(exchange);
        try {
            compressedInput = new LZFInputStream(inputStream);
            IOHelper.copy(compressedInput, osb);
            return osb.build();
        } finally {
             
            IOHelper.close(osb, compressedInput, inputStream);
        }
    }

    public static void parseXmlRouteCSimpleExpressions(
            InputStream xml, String baseDir, String fullyQualifiedFileName,
            List<CamelCSimpleExpressionDetails> csimpleExpressions) {

         
         
        Document dom = getDocument(xml);
        if (dom != null) {
            List<Node> nodes = CamelXmlHelper.findAllLanguageExpressions(dom, "csimple");
            for (Node node : nodes) {
                String simple = node.getTextContent();
                String lineNumber = (String) node.getUserData(XmlLineNumberParser.LINE_NUMBER);
                String lineNumberEnd = (String) node.getUserData(XmlLineNumberParser.LINE_NUMBER_END);

                 
                String fileName = getFileName(baseDir, fullyQualifiedFileName);

                CamelCSimpleExpressionDetails detail = new CamelCSimpleExpressionDetails();
                detail.setFileName(fileName);
                detail.setLineNumber(lineNumber);
                detail.setLineNumberEnd(lineNumberEnd);
                detail.setCsimple(simple);

                String column = (String) node.getUserData(XmlLineNumberParser.COLUMN_NUMBER);
                if (column != null) {
                    detail.setLinePosition(Integer.parseInt(column));
                }

                 
                boolean asPredicate = isSimplePredicate(node);
                detail.setPredicate(asPredicate);
                detail.setExpression(!asPredicate);

                csimpleExpressions.add(detail);
            }
        }
    }

    private SftpRemoteFile[] getSftpRemoteFiles(String dir) {
        SftpRemoteFile[] files = null;
        try {
            LOG.trace("Polling directory: {}", dir);
            if (isUseList()) {
                files = listFiles(dir);
            } else {
                files = pollNamedFile();
            }
        } catch (GenericFileOperationFailedException e) {
            if (ignoreCannotRetrieveFile(null, null, e)) {
                LOG.debug("Cannot list files in directory {} due directory does not exist or file permission error.", dir);
            } else {
                throw e;
            }
        }
        return files;
    }

    public Integer getIntegerOrDefault(final String key, final int defaultValue) {
        Object returnable;
        if (this.containsKey(key)) {
            returnable = this.get(key);
        } else {
            return defaultValue;
        }
        if (returnable == null) {
            return null;
        }
        if (returnable instanceof String) {
             
            returnable = new BigDecimal((String) returnable);
        }
        return ((Number) returnable).intValue();
    }

    private void doUpdate(Exchange exchange, String tableName) throws KuduException {
        LOG.trace("Update on table {}", tableName);
        KuduClient connection = endpoint.getKuduClient();
        KuduTable table = connection.openTable(tableName);

        Update update = table.newUpdate();
        PartialRow row = update.getRow();

        Map<?, ?> rows = exchange.getIn().getBody(Map.class);
        for (Map.Entry<?, ?> entry : rows.entrySet()) {
            final String colName = entry.getKey().toString();
            final Object value = entry.getValue();
            if (table.getSchema().getColumn(colName) != null) {
                row.addObject(colName, value);
            }
        }

        connection.newSession().apply(update);
    }

    public FluentProducerTemplate withExchangeProperty(String key, Object value) {
        DefaultFluentProducerTemplate clone = checkCloned();

        if (clone.processorSupplier != null) {
            throw new IllegalArgumentException(
                    "Cannot use both withExchangeProperty and withProcessor with FluentProducerTemplate");
        }

        Map<String, Object> map = clone.exchangeProperties;
        if (map == null) {
            map = new LinkedHashMap<>();
            clone.exchangeProperties = map;
        }
        map.put(key, value);
        return clone;
    }

    private void updateUser(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String userId = exchange.getIn().getHeader(KeycloakConstants.USER_ID, String.class);
        if (ObjectHelper.isEmpty(userId)) {
            throw new IllegalArgumentException(MISSING_USER_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof UserRepresentation) {
                keycloakClient.realm(realmName).users().get(userId).update((UserRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("User updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update user requires POJO request with UserRepresentation");
        }
    }

    public <K, V> BasicCache<K, V> getCache(String cacheName) {
        Cache<K, V> cache;
        if (ObjectHelper.isEmpty(cacheName) || CACHE_MANAGER_CURRENT.equals(cacheName)) {
            cache = cacheContainer.getCache();
        } else {
            cache = cacheContainer.getCache(cacheName);
        }

        return configuration.hasFlags()
                ? cache.getAdvancedCache().withFlags(configuration.getFlags())
                : cache;
    }

    private void createMavenPom(Path settings, Path pom, Set<String> deps) throws Exception {
        String[] ids = gav.split(":");

        InputStream is = ExportQuarkus.class.getClassLoader().getResourceAsStream("templates/" + pomTemplateName);
        String context = IOHelper.loadText(is);
        IOHelper.close(is);

        Properties prop = new CamelCaseOrderedProperties();
        RuntimeUtil.loadProperties(prop, settings);
         
        String repos = getMavenRepositories(settings, prop, quarkusVersion);

        CamelCatalog catalog = CatalogLoader.loadQuarkusCatalog(repos, quarkusVersion, quarkusGroupId, download);
        if (camelVersion == null) {
            camelVersion = catalog.getCatalogVersion();
        }

        String mp = prop.getProperty("quarkus.management.port");
        if (mp == null) {
            mp = "9876";
        }

        context = context.replaceAll("\\{\\{ \\.GroupId }}", ids[0]);
        context = context.replaceAll("\\{\\{ \\.ArtifactId }}", ids[1]);
        context = context.replaceAll("\\{\\{ \\.Version }}", ids[2]);
        context = context.replaceAll("\\{\\{ \\.QuarkusGroupId }}", quarkusGroupId);
        context = context.replaceAll("\\{\\{ \\.QuarkusArtifactId }}", quarkusArtifactId);
        context = context.replaceAll("\\{\\{ \\.QuarkusVersion }}", quarkusVersion);
        context = context.replaceAll("\\{\\{ \\.QuarkusManagementPort }}", mp);
        context = context.replaceAll("\\{\\{ \\.JavaVersion }}", javaVersion);
        context = context.replaceAll("\\{\\{ \\.CamelVersion }}", camelVersion);
        context = context.replaceAll("\\{\\{ \\.ProjectBuildOutputTimestamp }}", this.getBuildMavenProjectDate());

        context = replaceBuildProperties(context);

        if (repos == null || repos.isEmpty()) {
            context = context.replaceFirst("\\{\\{ \\.MavenRepositories }}", "");
        } else {
            String s = mavenRepositoriesAsPomXml(repos);
            context = context.replaceFirst("\\{\\{ \\.MavenRepositories }}", s);
        }

        List<MavenGav> gavs = new ArrayList<>();
        for (String dep : deps) {
            MavenGav gav = parseMavenGav(dep);
            String gid = gav.getGroupId();
            String aid = gav.getArtifactId();
             
            if ("org.apache.camel".equals(gid)) {
                String qaid = aid.replace("camel-", "camel-quarkus-");
                ArtifactModel<?> am = catalog.modelFromMavenGAV("org.apache.camel.quarkus", qaid, null);
                if (am != null) {
                     
                    gav.setGroupId(am.getGroupId());
                    gav.setArtifactId(am.getArtifactId());
                    gav.setVersion(null);  
                } else {
                     
                    gav.setVersion(camelVersion);
                }
            }
            gavs.add(gav);
        }

         
        replaceQuarkusDependencies(gavs);

         
        gavs.sort(mavenGavComparator());

        StringBuilder sb = new StringBuilder();
        for (MavenGav gav : gavs) {
             
            if ("camel-quarkus-core".equals(gav.getArtifactId())
                    || "camel-quarkus-microprofile-health".equals(gav.getArtifactId())) {
                continue;
            }
            sb.append("        <dependency>\n");
            sb.append("            <groupId>").append(gav.getGroupId()).append("</groupId>\n");
            sb.append("            <artifactId>").append(gav.getArtifactId()).append("</artifactId>\n");
            if (gav.getVersion() != null) {
                sb.append("            <version>").append(gav.getVersion()).append("</version>\n");
            }
            if (gav.getScope() != null) {
                sb.append("            <scope>").append(gav.getScope()).append("</scope>\n");
            }
            if ("lib".equals(gav.getPackaging())) {
                 
                sb.append("            <scope>system</scope>\n");
                sb.append("            <systemPath>\\$\\{project.basedir}/lib/").append(gav.getArtifactId()).append("-")
                        .append(gav.getVersion()).append(".jar</systemPath>\n");
            } else if ("camel-kamelets-utils".equals(gav.getArtifactId())) {
                 
                sb.append("            <exclusions>\n");
                sb.append("                <exclusion>\n");
                sb.append("                    <groupId>org.apache.camel</groupId>\n");
                sb.append("                    <artifactId>*</artifactId>\n");
                sb.append("                </exclusion>\n");
                sb.append("            </exclusions>\n");
            }
            sb.append("        </dependency>\n");
        }
        context = context.replaceFirst("\\{\\{ \\.CamelDependencies }}", sb.toString());

        Files.writeString(pom, context);
    }

    public void process(Exchange exchange) throws Exception {

        Map<String, Object> headers = exchange.getIn().getHeaders();

         
        Object oid = null;

        if (headers.containsKey(HazelcastConstants.OBJECT_ID)) {
            oid = headers.get(HazelcastConstants.OBJECT_ID);
        }

        final HazelcastOperation operation = lookupOperation(exchange);

        switch (operation) {
            case PUT:
                this.put(oid, exchange);
                break;

            case GET:
                this.get(oid, exchange);
                break;

            case DELETE:
                this.delete(oid);
                break;

            case REMOVE_VALUE:
                this.removevalue(oid, exchange);
                break;

            case CONTAINS_KEY:
                this.containsKey(oid, exchange);
                break;

            case CONTAINS_VALUE:
                this.containsValue(exchange);
                break;

            case CLEAR:
                this.clear();
                break;

            case VALUE_COUNT:
                this.valuecount(oid, exchange);
                break;

            default:
                throw new IllegalArgumentException(
                        String.format("The value '%s' is not allowed for parameter '%s' on the MULTIMAP cache.", operation,
                                HazelcastConstants.OPERATION));
        }

         
        HazelcastComponentHelper.copyHeaders(exchange);
    }

    private void deleteById(Exchange exchange) throws Exception {
        final Message in = exchange.getMessage();
        String indexId = ExchangeHelper.getMandatoryHeader(exchange, WeaviateVectorDbHeaders.INDEX_ID, String.class);

         
         
        String collectionName;
        if (in.getHeader(WeaviateVectorDbHeaders.COLLECTION_NAME, String.class) != null) {
            collectionName = in.getHeader(WeaviateVectorDbHeaders.COLLECTION_NAME, String.class);
        } else {
            collectionName = getEndpoint().getCollection();
        }
        Result<Boolean> result = this.client.data().deleter()
                .withClassName(collectionName)
                .withID(indexId)
                .run();
        populateResponse(result, exchange);
    }

    private void validatePermissions(String accessToken, Exchange exchange) throws Exception {
        try {
            Set<String> userPermissions;

             
            if (policy.isUseTokenIntrospection() && policy.getTokenIntrospector() != null) {
                KeycloakTokenIntrospector.IntrospectionResult introspectionResult
                        = KeycloakSecurityHelper.introspectToken(accessToken, policy.getTokenIntrospector());

                 
                if (!introspectionResult.isActive()) {
                    throw new CamelAuthorizationException("Token is not active (may be revoked or expired)", exchange);
                }

                userPermissions = KeycloakSecurityHelper.extractPermissionsFromIntrospection(introspectionResult);
            } else {
                 
                AccessToken token;
                if (ObjectHelper.isEmpty(policy.getPublicKey())) {
                    token = KeycloakSecurityHelper.parseAccessToken(accessToken);
                } else {
                    token = KeycloakSecurityHelper.parseAccessToken(accessToken, policy.getPublicKey());
                }
                userPermissions = KeycloakSecurityHelper.extractPermissions(token);
            }

            boolean hasRequiredPermissions = policy.isAllPermissionsRequired()
                    ? userPermissions.containsAll(policy.getRequiredPermissionsAsList())
                    : policy.getRequiredPermissionsAsList().stream().anyMatch(userPermissions::contains);

            if (!hasRequiredPermissions) {
                String message = String.format("User does not have required permissions. Required: %s, User has: %s",
                        policy.getRequiredPermissions(), userPermissions);
                LOG.debug(message);
                throw new CamelAuthorizationException(message, exchange);
            }

            LOG.debug("Permission validation successful for user with permissions: {}", userPermissions);

        } catch (Exception e) {
            if (e instanceof CamelAuthorizationException) {
                throw e;
            }
            throw new CamelAuthorizationException("Failed to validate permissions", exchange, e);
        }
    }

        void cleanUpTempFile() {
             
            try {
                if (tempFile != null) {
                    FileUtil.deleteFile(tempFile);
                    tempFile = null;
                }
            } catch (Exception e) {
                LOG.warn("Error deleting temporary cache file: {}. This exception will be ignored.", tempFile, e);
            }
        }

    public String getServiceUrl() {
        if (!getConfiguration().isOverrideEndpoint()) {
            if (ObjectHelper.isNotEmpty(getConfiguration().getRegion())) {
                return getConfiguration().getRegion();
            }
        } else if (ObjectHelper.isNotEmpty(getConfiguration().getUriEndpointOverride())) {
            return getConfiguration().getUriEndpointOverride();
        }
        return null;
    }

    protected boolean doRun(BooleanSupplier supplier) {
        try {
            cause = null;
            return supplier.getAsBoolean();
        } catch (TaskRunFailureException e) {
            LOG.debug("Task {} failed at {} iterations and will attempt again on next interval: {}",
                    getName(), budget.iteration(), e.getMessage());
            cause = e;
            return false;
        }
    }

    protected Boolean omitXmlDeclaration(Message message, Input input) {
        Boolean omitXmlDeclaration = message.getHeader(XmlSignatureConstants.HEADER_OMIT_XML_DECLARATION, Boolean.class);
        if (omitXmlDeclaration == null) {
            omitXmlDeclaration = input.omitXmlDeclaration();
        }
        if (omitXmlDeclaration == null) {
            omitXmlDeclaration = Boolean.FALSE;
        }
        return omitXmlDeclaration;
    }

    private static Object asDefaultValue(String type, String defaultValue) {
        if (defaultValue != null) {
            if ("boolean".equals(type)) {
                return Boolean.parseBoolean(defaultValue);
            } else if ("integer".equals(type)) {
                return Integer.parseInt(defaultValue);
            }
        }
        if (defaultValue == null && "boolean".equals(type)) {
            return "false";
        }
        return defaultValue;
    }

    protected String getSource(Annotation annotation) {
        String answer = null;
        try {
            answer = (String) getAnnotationObjectValue(annotation, "source");
        } catch (Exception e) {
             
        }
        if (answer != null && answer.isBlank()) {
            return null;
        }
        return answer;
    }

    private void startAllStoppedConsumers() {
        lock.lock();
        try {
            for (Route route : suspendedRoutes) {
                LOGGER.debug("Starting consumer for {} ({})", route.getId(), route.getConsumer());
                startConsumer(route.getConsumer());
            }

            suspendedRoutes.clear();
        } catch (Exception e) {
            handleException(e);
        } finally {
            lock.unlock();
        }
    }

        protected boolean setPropertyOnComponent(
                Component component,
                String name,
                Object value) {
            switch (name) {
            case "additionalProperties": getOrCreateConfiguration((DebeziumOracleComponent) component).setAdditionalProperties((java.util.Map) value); return true;
            case "bridgeErrorHandler": ((DebeziumOracleComponent) component).setBridgeErrorHandler((boolean) value); return true;
            case "configuration": ((DebeziumOracleComponent) component).setConfiguration((org.apache.camel.component.debezium.oracle.configuration.OracleConnectorEmbeddedDebeziumConfiguration) value); return true;
            case "internalKeyConverter": getOrCreateConfiguration((DebeziumOracleComponent) component).setInternalKeyConverter((java.lang.String) value); return true;
            case "internalValueConverter": getOrCreateConfiguration((DebeziumOracleComponent) component).setInternalValueConverter((java.lang.String) value); return true;
            case "offsetCommitPolicy": getOrCreateConfiguration((DebeziumOracleComponent) component).setOffsetCommitPolicy((java.lang.String) value); return true;
            case "offsetCommitTimeoutMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setOffsetCommitTimeoutMs((long) value); return true;
            case "offsetFlushIntervalMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setOffsetFlushIntervalMs((long) value); return true;
            case "offsetStorage": getOrCreateConfiguration((DebeziumOracleComponent) component).setOffsetStorage((java.lang.String) value); return true;
            case "offsetStorageFileName": getOrCreateConfiguration((DebeziumOracleComponent) component).setOffsetStorageFileName((java.lang.String) value); return true;
            case "offsetStoragePartitions": getOrCreateConfiguration((DebeziumOracleComponent) component).setOffsetStoragePartitions((int) value); return true;
            case "offsetStorageReplicationFactor": getOrCreateConfiguration((DebeziumOracleComponent) component).setOffsetStorageReplicationFactor((int) value); return true;
            case "offsetStorageTopic": getOrCreateConfiguration((DebeziumOracleComponent) component).setOffsetStorageTopic((java.lang.String) value); return true;
            case "autowiredEnabled": ((DebeziumOracleComponent) component).setAutowiredEnabled((boolean) value); return true;
            case "archiveDestinationName": getOrCreateConfiguration((DebeziumOracleComponent) component).setArchiveDestinationName((java.lang.String) value); return true;
            case "archiveLogHours": getOrCreateConfiguration((DebeziumOracleComponent) component).setArchiveLogHours((long) value); return true;
            case "binaryHandlingMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setBinaryHandlingMode((java.lang.String) value); return true;
            case "columnExcludeList": getOrCreateConfiguration((DebeziumOracleComponent) component).setColumnExcludeList((java.lang.String) value); return true;
            case "columnIncludeList": getOrCreateConfiguration((DebeziumOracleComponent) component).setColumnIncludeList((java.lang.String) value); return true;
            case "columnPropagateSourceType": getOrCreateConfiguration((DebeziumOracleComponent) component).setColumnPropagateSourceType((java.lang.String) value); return true;
            case "connectionValidationTimeoutMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setConnectionValidationTimeoutMs((long) value); return true;
            case "converters": getOrCreateConfiguration((DebeziumOracleComponent) component).setConverters((java.lang.String) value); return true;
            case "customMetricTags": getOrCreateConfiguration((DebeziumOracleComponent) component).setCustomMetricTags((java.lang.String) value); return true;
            case "customSanitizePattern": getOrCreateConfiguration((DebeziumOracleComponent) component).setCustomSanitizePattern((java.lang.String) value); return true;
            case "databaseConnectionAdapter": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabaseConnectionAdapter((java.lang.String) value); return true;
            case "databaseDbname": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabaseDbname((java.lang.String) value); return true;
            case "databaseHostname": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabaseHostname((java.lang.String) value); return true;
            case "databaseOutServerName": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabaseOutServerName((java.lang.String) value); return true;
            case "databasePassword": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabasePassword((java.lang.String) value); return true;
            case "databasePdbName": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabasePdbName((java.lang.String) value); return true;
            case "databasePort": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabasePort((int) value); return true;
            case "databaseQueryTimeoutMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabaseQueryTimeoutMs((int) value); return true;
            case "databaseUrl": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabaseUrl((java.lang.String) value); return true;
            case "databaseUser": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabaseUser((java.lang.String) value); return true;
            case "datatypePropagateSourceType": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatatypePropagateSourceType((java.lang.String) value); return true;
            case "decimalHandlingMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setDecimalHandlingMode((java.lang.String) value); return true;
            case "errorsMaxRetries": getOrCreateConfiguration((DebeziumOracleComponent) component).setErrorsMaxRetries((int) value); return true;
            case "eventProcessingFailureHandlingMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setEventProcessingFailureHandlingMode((java.lang.String) value); return true;
            case "executorShutdownTimeoutMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setExecutorShutdownTimeoutMs((long) value); return true;
            case "extendedHeadersEnabled": getOrCreateConfiguration((DebeziumOracleComponent) component).setExtendedHeadersEnabled((boolean) value); return true;
            case "guardrailCollectionsLimitAction": getOrCreateConfiguration((DebeziumOracleComponent) component).setGuardrailCollectionsLimitAction((java.lang.String) value); return true;
            case "guardrailCollectionsMax": getOrCreateConfiguration((DebeziumOracleComponent) component).setGuardrailCollectionsMax((int) value); return true;
            case "heartbeatActionQuery": getOrCreateConfiguration((DebeziumOracleComponent) component).setHeartbeatActionQuery((java.lang.String) value); return true;
            case "heartbeatIntervalMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setHeartbeatIntervalMs((int) value); return true;
            case "heartbeatTopicsPrefix": getOrCreateConfiguration((DebeziumOracleComponent) component).setHeartbeatTopicsPrefix((java.lang.String) value); return true;
            case "includeSchemaChanges": getOrCreateConfiguration((DebeziumOracleComponent) component).setIncludeSchemaChanges((boolean) value); return true;
            case "includeSchemaComments": getOrCreateConfiguration((DebeziumOracleComponent) component).setIncludeSchemaComments((boolean) value); return true;
            case "incrementalSnapshotWatermarkingStrategy": getOrCreateConfiguration((DebeziumOracleComponent) component).setIncrementalSnapshotWatermarkingStrategy((java.lang.String) value); return true;
            case "intervalHandlingMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setIntervalHandlingMode((java.lang.String) value); return true;
            case "legacyDecimalHandlingStrategy": getOrCreateConfiguration((DebeziumOracleComponent) component).setLegacyDecimalHandlingStrategy((boolean) value); return true;
            case "lobEnabled": getOrCreateConfiguration((DebeziumOracleComponent) component).setLobEnabled((boolean) value); return true;
            case "logMiningArchiveLogOnlyMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningArchiveLogOnlyMode((boolean) value); return true;
            case "logMiningArchiveLogOnlyScnPollIntervalMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningArchiveLogOnlyScnPollIntervalMs((long) value); return true;
            case "logMiningBatchSizeDefault": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBatchSizeDefault((long) value); return true;
            case "logMiningBatchSizeIncrement": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBatchSizeIncrement((long) value); return true;
            case "logMiningBatchSizeMax": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBatchSizeMax((long) value); return true;
            case "logMiningBatchSizeMin": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBatchSizeMin((long) value); return true;
            case "logMiningBufferDropOnStop": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferDropOnStop((boolean) value); return true;
            case "logMiningBufferEhcacheEventsConfig": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferEhcacheEventsConfig((java.lang.String) value); return true;
            case "logMiningBufferEhcacheGlobalConfig": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferEhcacheGlobalConfig((java.lang.String) value); return true;
            case "logMiningBufferEhcacheProcessedtransactionsConfig": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferEhcacheProcessedtransactionsConfig((java.lang.String) value); return true;
            case "logMiningBufferEhcacheSchemachangesConfig": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferEhcacheSchemachangesConfig((java.lang.String) value); return true;
            case "logMiningBufferEhcacheTransactionsConfig": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferEhcacheTransactionsConfig((java.lang.String) value); return true;
            case "logMiningBufferInfinispanCacheEvents": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferInfinispanCacheEvents((java.lang.String) value); return true;
            case "logMiningBufferInfinispanCacheGlobal": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferInfinispanCacheGlobal((java.lang.String) value); return true;
            case "logMiningBufferInfinispanCacheProcessedTransactions": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferInfinispanCacheProcessedTransactions((java.lang.String) value); return true;
            case "logMiningBufferInfinispanCacheSchemaChanges": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferInfinispanCacheSchemaChanges((java.lang.String) value); return true;
            case "logMiningBufferInfinispanCacheTransactions": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferInfinispanCacheTransactions((java.lang.String) value); return true;
            case "logMiningBufferTransactionEventsThreshold": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferTransactionEventsThreshold((long) value); return true;
            case "logMiningBufferType": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferType((java.lang.String) value); return true;
            case "logMiningClientidExcludeList": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningClientidExcludeList((java.lang.String) value); return true;
            case "logMiningClientidIncludeList": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningClientidIncludeList((java.lang.String) value); return true;
            case "logMiningFlushTableName": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningFlushTableName((java.lang.String) value); return true;
            case "logMiningIncludeRedoSql": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningIncludeRedoSql((boolean) value); return true;
            case "logMiningPathDictionary": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningPathDictionary((java.lang.String) value); return true;
            case "logMiningQueryFilterMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningQueryFilterMode((java.lang.String) value); return true;
            case "logMiningReadonlyHostname": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningReadonlyHostname((java.lang.String) value); return true;
            case "logMiningRestartConnection": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningRestartConnection((boolean) value); return true;
            case "logMiningScnGapDetectionGapSizeMin": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningScnGapDetectionGapSizeMin((long) value); return true;
            case "logMiningScnGapDetectionTimeIntervalMaxMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningScnGapDetectionTimeIntervalMaxMs((long) value); return true;
            case "logMiningSessionMaxMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningSessionMaxMs((long) value); return true;
            case "logMiningSleepTimeDefaultMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningSleepTimeDefaultMs((long) value); return true;
            case "logMiningSleepTimeIncrementMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningSleepTimeIncrementMs((long) value); return true;
            case "logMiningSleepTimeMaxMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningSleepTimeMaxMs((long) value); return true;
            case "logMiningSleepTimeMinMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningSleepTimeMinMs((long) value); return true;
            case "logMiningStrategy": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningStrategy((java.lang.String) value); return true;
            case "logMiningTransactionRetentionMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningTransactionRetentionMs((long) value); return true;
            case "logMiningUsernameExcludeList": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningUsernameExcludeList((java.lang.String) value); return true;
            case "logMiningUsernameIncludeList": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningUsernameIncludeList((java.lang.String) value); return true;
            case "maxBatchSize": getOrCreateConfiguration((DebeziumOracleComponent) component).setMaxBatchSize((int) value); return true;
            case "maxQueueSize": getOrCreateConfiguration((DebeziumOracleComponent) component).setMaxQueueSize((int) value); return true;
            case "maxQueueSizeInBytes": getOrCreateConfiguration((DebeziumOracleComponent) component).setMaxQueueSizeInBytes((long) value); return true;
            case "messageKeyColumns": getOrCreateConfiguration((DebeziumOracleComponent) component).setMessageKeyColumns((java.lang.String) value); return true;
            case "notificationEnabledChannels": getOrCreateConfiguration((DebeziumOracleComponent) component).setNotificationEnabledChannels((java.lang.String) value); return true;
            case "notificationSinkTopicName": getOrCreateConfiguration((DebeziumOracleComponent) component).setNotificationSinkTopicName((java.lang.String) value); return true;
            case "openlineageIntegrationConfigFilePath": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlineageIntegrationConfigFilePath((java.lang.String) value); return true;
            case "openlineageIntegrationDatasetKafkaBootstrapServers": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlineageIntegrationDatasetKafkaBootstrapServers((java.lang.String) value); return true;
            case "openlineageIntegrationEnabled": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlineageIntegrationEnabled((boolean) value); return true;
            case "openlineageIntegrationJobDescription": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlineageIntegrationJobDescription((java.lang.String) value); return true;
            case "openlineageIntegrationJobNamespace": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlineageIntegrationJobNamespace((java.lang.String) value); return true;
            case "openlineageIntegrationJobOwners": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlineageIntegrationJobOwners((java.lang.String) value); return true;
            case "openlineageIntegrationJobTags": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlineageIntegrationJobTags((java.lang.String) value); return true;
            case "openlogreplicatorHost": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlogreplicatorHost((java.lang.String) value); return true;
            case "openlogreplicatorPort": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlogreplicatorPort((int) value); return true;
            case "openlogreplicatorSource": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlogreplicatorSource((java.lang.String) value); return true;
            case "pollIntervalMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setPollIntervalMs((long) value); return true;
            case "postProcessors": getOrCreateConfiguration((DebeziumOracleComponent) component).setPostProcessors((java.lang.String) value); return true;
            case "provideTransactionMetadata": getOrCreateConfiguration((DebeziumOracleComponent) component).setProvideTransactionMetadata((boolean) value); return true;
            case "queryFetchSize": getOrCreateConfiguration((DebeziumOracleComponent) component).setQueryFetchSize((int) value); return true;
            case "racNodes": getOrCreateConfiguration((DebeziumOracleComponent) component).setRacNodes((java.lang.String) value); return true;
            case "retriableRestartConnectorWaitMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setRetriableRestartConnectorWaitMs((long) value); return true;
            case "schemaHistoryInternal": getOrCreateConfiguration((DebeziumOracleComponent) component).setSchemaHistoryInternal((java.lang.String) value); return true;
            case "schemaHistoryInternalFileFilename": getOrCreateConfiguration((DebeziumOracleComponent) component).setSchemaHistoryInternalFileFilename((java.lang.String) value); return true;
            case "schemaHistoryInternalSkipUnparseableDdl": getOrCreateConfiguration((DebeziumOracleComponent) component).setSchemaHistoryInternalSkipUnparseableDdl((boolean) value); return true;
            case "schemaHistoryInternalStoreOnlyCapturedDatabasesDdl": getOrCreateConfiguration((DebeziumOracleComponent) component).setSchemaHistoryInternalStoreOnlyCapturedDatabasesDdl((boolean) value); return true;
            case "schemaHistoryInternalStoreOnlyCapturedTablesDdl": getOrCreateConfiguration((DebeziumOracleComponent) component).setSchemaHistoryInternalStoreOnlyCapturedTablesDdl((boolean) value); return true;
            case "schemaNameAdjustmentMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setSchemaNameAdjustmentMode((java.lang.String) value); return true;
            case "signalDataCollection": getOrCreateConfiguration((DebeziumOracleComponent) component).setSignalDataCollection((java.lang.String) value); return true;
            case "signalEnabledChannels": getOrCreateConfiguration((DebeziumOracleComponent) component).setSignalEnabledChannels((java.lang.String) value); return true;
            case "signalPollIntervalMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setSignalPollIntervalMs((long) value); return true;
            case "skippedOperations": getOrCreateConfiguration((DebeziumOracleComponent) component).setSkippedOperations((java.lang.String) value); return true;
            case "snapshotDatabaseErrorsMaxRetries": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotDatabaseErrorsMaxRetries((int) value); return true;
            case "snapshotDelayMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotDelayMs((long) value); return true;
            case "snapshotFetchSize": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotFetchSize((int) value); return true;
            case "snapshotIncludeCollectionList": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotIncludeCollectionList((java.lang.String) value); return true;
            case "snapshotLockingMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotLockingMode((java.lang.String) value); return true;
            case "snapshotLockTimeoutMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotLockTimeoutMs((long) value); return true;
            case "snapshotMaxThreads": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotMaxThreads((int) value); return true;
            case "snapshotMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotMode((java.lang.String) value); return true;
            case "snapshotModeConfigurationBasedSnapshotData": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotModeConfigurationBasedSnapshotData((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotOnDataError": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotModeConfigurationBasedSnapshotOnDataError((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotOnSchemaError": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotModeConfigurationBasedSnapshotOnSchemaError((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotSchema": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotModeConfigurationBasedSnapshotSchema((boolean) value); return true;
            case "snapshotModeConfigurationBasedStartStream": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotModeConfigurationBasedStartStream((boolean) value); return true;
            case "snapshotModeCustomName": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotModeCustomName((java.lang.String) value); return true;
            case "snapshotSelectStatementOverrides": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotSelectStatementOverrides((java.lang.String) value); return true;
            case "snapshotTablesOrderByRowCount": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotTablesOrderByRowCount((java.lang.String) value); return true;
            case "sourceinfoStructMaker": getOrCreateConfiguration((DebeziumOracleComponent) component).setSourceinfoStructMaker((java.lang.String) value); return true;
            case "streamingDelayMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setStreamingDelayMs((long) value); return true;
            case "tableExcludeList": getOrCreateConfiguration((DebeziumOracleComponent) component).setTableExcludeList((java.lang.String) value); return true;
            case "tableIncludeList": getOrCreateConfiguration((DebeziumOracleComponent) component).setTableIncludeList((java.lang.String) value); return true;
            case "timePrecisionMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setTimePrecisionMode((java.lang.String) value); return true;
            case "tombstonesOnDelete": getOrCreateConfiguration((DebeziumOracleComponent) component).setTombstonesOnDelete((boolean) value); return true;
            case "topicNamingStrategy": getOrCreateConfiguration((DebeziumOracleComponent) component).setTopicNamingStrategy((java.lang.String) value); return true;
            case "topicPrefix": getOrCreateConfiguration((DebeziumOracleComponent) component).setTopicPrefix((java.lang.String) value); return true;
            case "transactionMetadataFactory": getOrCreateConfiguration((DebeziumOracleComponent) component).setTransactionMetadataFactory((java.lang.String) value); return true;
            case "unavailableValuePlaceholder": getOrCreateConfiguration((DebeziumOracleComponent) component).setUnavailableValuePlaceholder((java.lang.String) value); return true;
            default: return false;
            }
        }

    protected T predict(Exchange exchange, String input) {
        Model model = exchange.getContext().getRegistry().lookupByNameAndType(modelName, Model.class);
        @SuppressWarnings("unchecked")
        Translator<String, T> translator
                = exchange.getContext().getRegistry().lookupByNameAndType(translatorName, Translator.class);

        exchange.getIn().setHeader(DJLConstants.INPUT, input);
        try (Predictor<String, T> predictor = model.newPredictor(translator)) {
            return predictor.predict(input);
        } catch (TranslateException e) {
            throw new RuntimeCamelException("Could not process input or output", e);
        }
    }

    public Properties createConsumerProperties() {
        Properties props = new Properties();
        addPropertyIfNotEmpty(props, ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, getKeyDeserializer());
        addPropertyIfNotEmpty(props, ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, getValueDeserializer());
        addPropertyIfNotEmpty(props, ConsumerConfig.FETCH_MIN_BYTES_CONFIG, getFetchMinBytes());
        addPropertyIfNotEmpty(props, ConsumerConfig.FETCH_MAX_BYTES_CONFIG, getFetchMaxBytes());
        addPropertyIfNotEmpty(props, ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG, getHeartbeatIntervalMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.MAX_PARTITION_FETCH_BYTES_CONFIG, getMaxPartitionFetchBytes());
        addPropertyIfNotEmpty(props, ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, getSessionTimeoutMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG, getMaxPollIntervalMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.MAX_POLL_RECORDS_CONFIG, getMaxPollRecords());
        addPropertyIfNotEmpty(props, ConsumerConfig.INTERCEPTOR_CLASSES_CONFIG, getInterceptorClasses());
        addPropertyIfNotEmpty(props, ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, getAutoOffsetReset());
        addPropertyIfNotEmpty(props, ConsumerConfig.CONNECTIONS_MAX_IDLE_MS_CONFIG, getConnectionMaxIdleMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, getAutoCommitEnable());
        addPropertyIfNotEmpty(props, ConsumerConfig.PARTITION_ASSIGNMENT_STRATEGY_CONFIG, getPartitionAssignor());
        addPropertyIfNotEmpty(props, ConsumerConfig.RECEIVE_BUFFER_CONFIG, getReceiveBufferBytes());
        addPropertyIfNotEmpty(props, ConsumerConfig.REQUEST_TIMEOUT_MS_CONFIG, getConsumerRequestTimeoutMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, getAutoCommitIntervalMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.CHECK_CRCS_CONFIG, getCheckCrcs());
        addPropertyIfNotEmpty(props, ConsumerConfig.CLIENT_ID_CONFIG, getClientId());
        addPropertyIfNotEmpty(props, ConsumerConfig.FETCH_MAX_WAIT_MS_CONFIG, getFetchWaitMaxMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.METADATA_MAX_AGE_CONFIG, getMetadataMaxAgeMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.METRIC_REPORTER_CLASSES_CONFIG, getMetricReporters());
        addPropertyIfNotEmpty(props, ConsumerConfig.METRICS_NUM_SAMPLES_CONFIG, getNoOfMetricsSample());
        addPropertyIfNotEmpty(props, ConsumerConfig.METRICS_SAMPLE_WINDOW_MS_CONFIG, getMetricsSampleWindowMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.RECONNECT_BACKOFF_MS_CONFIG, getReconnectBackoffMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.RETRY_BACKOFF_MS_CONFIG, getRetryBackoffMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.RETRY_BACKOFF_MAX_MS_CONFIG, getRetryBackoffMaxMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.RECONNECT_BACKOFF_MAX_MS_CONFIG, getReconnectBackoffMaxMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.ISOLATION_LEVEL_CONFIG, getIsolationLevel());
        addPropertyIfNotEmpty(props, "schema.registry.url", getSchemaRegistryURL());
        addPropertyIfNotFalse(props, "specific.avro.reader", isSpecificAvroReader());

         
        if (sslContextParameters != null) {
            applySslConfigurationFromContext(props, sslContextParameters);
        } else {
            applySslConsumerConfigurationFromOptions(props);
        }

         
        addPropertyIfNotEmpty(props, CommonClientConfigs.SECURITY_PROTOCOL_CONFIG, securityProtocol);

         
        if (isSasl(securityProtocol)) {
            applySaslConfiguration(props);
        }

         
        applyAdditionalProperties(props, getAdditionalProperties());

        return props;
    }

    public void completedExchange(Exchange exchange, long time) {
         
         
         
         
        UnitOfWork uow = exchange.getUnitOfWork();
        if (uow != null) {
            int level = uow.routeStackLevel(includeRouteTemplates, includeKamelets);
            if (level <= 1) {
                super.completedExchange(exchange, time);
                if (exchange.getFromEndpoint() != null && exchange.getFromEndpoint().isRemote()) {
                    remoteExchangesTotal.increment();
                    remoteExchangesCompleted.increment();
                    remoteExchangesInflight.decrement();
                }
            }
        } else {
            super.completedExchange(exchange, time);
            if (exchange.getFromEndpoint() != null && exchange.getFromEndpoint().isRemote()) {
                remoteExchangesTotal.increment();
                remoteExchangesCompleted.increment();
                remoteExchangesInflight.decrement();
            }
        }
    }

    public NettyHttpConfiguration copy() {
        try {
             
            NettyHttpConfiguration answer = (NettyHttpConfiguration) clone();
             
            answer.setEncodersAsList(new ArrayList<>(getEncodersAsList()));
            answer.setDecodersAsList(new ArrayList<>(getDecodersAsList()));
            return answer;
        } catch (CloneNotSupportedException e) {
            throw new RuntimeCamelException(e);
        }
    }

    public <K, V> BasicCache<K, V> getCache(String cacheName) {
        RemoteCache<K, V> cache;
        if (ObjectHelper.isEmpty(cacheName) || CACHE_MANAGER_CURRENT.equals(cacheName)) {
            cache = cacheContainer.getCache();
        } else {
            cache = cacheContainer.getCache(cacheName);
        }

        return configuration.hasFlags()
                ? cache.withFlags(configuration.getFlags())
                : cache;
    }

    static long write(FileChannel fileChannel, ByteBuffer byteBuffer) throws IOException {
        long bytesWritten = 0;
        byteBuffer.flip();

        while (byteBuffer.hasRemaining()) {
            bytesWritten += fileChannel.write(byteBuffer);
        }

        byteBuffer.flip();
        byteBuffer.clear();

        return bytesWritten;
    }

    JsonObject loadStatus(long pid) {
        try {
            Path f = getStatusFile(Long.toString(pid));
            if (f != null && Files.exists(f)) {
                String text = Files.readString(f);
                return (JsonObject) Jsoner.deserialize(text);
            }
        } catch (Exception e) {
             
        }
        return null;
    }

    public static DocumentBuilderFactory createDocumentBuilderFactory() {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        factory.setNamespaceAware(true);
        factory.setIgnoringElementContentWhitespace(true);
        factory.setIgnoringComments(true);
        try {
             
            factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, Boolean.TRUE);
        } catch (ParserConfigurationException e) {
        }
        try {
             
            factory.setFeature("http://xml.org/sax/features/external-general-entities", false);
        } catch (ParserConfigurationException e) {
        }
        try {
             
            factory.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
        } catch (ParserConfigurationException e) {
        }
         
        try {
            Class<?> smClass = ObjectHelper.loadClass("org.apache.xerces.util.SecurityManager");
            if (smClass != null) {
                Object sm = smClass.getDeclaredConstructor().newInstance();
                 
                factory.setAttribute("http://apache.org/xml/properties/security-manager", sm);
            }
        } catch (Exception e) {
        }
        return factory;
    }

    private void updateFunction(CloudFunctionsServiceClient client, Exchange exchange)
            throws InvalidPayloadException, InterruptedException, ExecutionException {
        CloudFunction response = null;
        if (getConfiguration().isPojoRequest()) {
            UpdateFunctionRequest request = exchange.getIn().getMandatoryBody(UpdateFunctionRequest.class);
            response = client.updateFunctionAsync(request).get();
        } else {
            throw new IllegalArgumentException("updateFunction is supported only in pojo mode");
        }
        Message message = getMessageForResponse(exchange);
        message.setBody(response);
    }

    private void processUpsertSobject(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {
        String sObjectName = determineSObjectName(exchange);
        String sObjectExtIdValue;
        final String sObjectExtIdName = getParameter(SOBJECT_EXT_ID_NAME, exchange, IGNORE_BODY, NOT_OPTIONAL);

         
        Object oldValue = null;
        final AbstractSObjectBase sObjectBase = exchange.getIn().getBody(AbstractSObjectBase.class);
        if (sObjectBase != null) {
            oldValue = getAndClearPropertyValue(sObjectBase, sObjectExtIdName);
            sObjectExtIdValue = oldValue.toString();
             
            sObjectBase.clearBaseFields();
        } else {
            sObjectExtIdValue = getParameter(SOBJECT_EXT_ID_VALUE, exchange, IGNORE_BODY, NOT_OPTIONAL);
        }

        final Object finalOldValue = oldValue;
        restClient.upsertSObject(sObjectName, sObjectExtIdName, sObjectExtIdValue, determineHeaders(exchange),
                getRequestStream(exchange), new RestClient.ResponseCallback() {
                    @Override
                    public void onResponse(InputStream response, Map<String, String> headers, SalesforceException exception) {
                        restoreFields(exchange, sObjectBase, null, sObjectExtIdName, finalOldValue);
                        processResponse(exchange, response, headers, exception, callback);
                    }
                });
    }

    private Processor defaultAsyncProcessor() {
        final Map<String, Object> headersCopy = ObjectHelper.isNotEmpty(this.headers) ? new HashMap<>(this.headers) : null;
        final Map<String, Object> propertiesCopy
                = ObjectHelper.isNotEmpty(this.exchangeProperties) ? new HashMap<>(this.exchangeProperties) : null;
        final Map<String, Object> variablesCopy
                = ObjectHelper.isNotEmpty(this.variables) ? new HashMap<>(this.variables) : null;
        final Object bodyCopy = this.body;
        return exchange -> {
            if (headersCopy != null) {
                exchange.getIn().getHeaders().putAll(headersCopy);
            }
            if (propertiesCopy != null) {
                exchange.getProperties().putAll(propertiesCopy);
            }
            if (bodyCopy != null) {
                exchange.getIn().setBody(bodyCopy);
            }
            if (variablesCopy != null) {
                variablesCopy.forEach((k, v) -> ExchangeHelper.setVariable(exchange, k, v));
            }
        };
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
         
        if (!isRunAllowed()) {
            if (exchange.getException() == null) {
                exchange.setException(new RejectedExecutionException());
            }
             
            callback.done(true);
            return true;
        }

        try {
            if (!endpoint.isDisableReplyTo() && exchange.getPattern().isOutCapable()) {
                 
                return processInOut(exchange, callback);
            } else {
                 
                return processInOnly(exchange, callback);
            }
        } catch (Exception e) {
             
             
            exchange.setException(e);
            callback.done(true);
            return true;
        }
    }

    private Integer doCallLocal() throws Exception {
        AtomicReference<KameletMain> ref = new AtomicReference<>();
        Run run = new Run(this.getMain()) {
            @Override
            protected int runKameletMain(KameletMain main) throws Exception {
                ref.set(main);
                return super.runKameletMain(main);
            }
        };
        run.empty = true;
        run.propertiesFiles = propertiesFiles;
        run.property = property;

         
        final CountDownLatch latch = new CountDownLatch(1);
        this.pid = ProcessHandle.current().pid();
        Path outputFile = writeSendData();
        Thread t = new Thread("CamelJBangSendStatus") {
            @Override
            public void run() {
                try {
                    showStatus(outputFile);
                } catch (Exception e) {
                     
                } finally {
                    latch.countDown();
                     
                    KameletMain main = ref.get();
                    if (main != null) {
                        main.completed();
                    }
                }
            }
        };
         
        t.start();

        Integer exit = run.call();
        latch.await(timeout + 10000, TimeUnit.MILLISECONDS);

        return exit;
    }

    private static String getMethodJavadocRaw(MethodSource ms, String rawClass) {
        Object obj = ms.getJavaDoc().getInternal();
        ASTNode node = (ASTNode) obj;
        int pos = node.getStartPosition();
        int len = node.getLength();
        if (pos > 0 && len > 0) {
            return rawClass.substring(pos, pos + len);
        } else {
            return null;
        }
    }

    private boolean updateOptionsIn(final File file, final String kind, final String changed) throws MojoExecutionException {
        if (!file.exists()) {
            return false;
        }

        final String updated = changed.trim();
        try {
            String text = PackageHelper.loadText(file);

            String existing = Strings.between(text, "// " + kind + " options: START", "// " + kind + " options: END");
            if (existing != null) {
                 
                existing = existing.trim();
                if (existing.equals(updated)) {
                    return false;
                }

                String before = Strings.before(text, "// " + kind + " options: START");
                String after = Strings.after(text, "// " + kind + " options: END");
                text = before + "// " + kind + " options: START\n" + updated + "\n// " + kind + " options: END" + after;
                PackageHelper.writeText(file, text);
                return true;
            }

            getLog().warn("Cannot find markers in file " + file);
            getLog().warn("Add the following markers");
            getLog().warn("\t// " + kind + " options: START");
            getLog().warn("\t// " + kind + " options: END");
            return false;
        } catch (IOException e) {
            throw new MojoExecutionException("Error reading file " + file + " Reason: " + e, e);
        }
    }

    private void createRecord(Exchange exchange) throws Exception {
        final Message in = exchange.getIn();
        final String tableName = getTableName(in);
        final String apiVersion = getApiVersion(in);
        final Class<?> requestModel = getRequestModel(in, tableName);
        final Class<?> responseModel = getResponseModel(in, tableName);

        validateBody(in, requestModel);

        Response response = client.reset()
                .types(MediaType.APPLICATION_JSON_TYPE)
                .path("now")
                .path(apiVersion)
                .path("table")
                .path(tableName)
                .query(ServiceNowParams.SYSPARM_DISPLAY_VALUE, in)
                .query(ServiceNowParams.SYSPARM_EXCLUDE_REFERENCE_LINK, in)
                .query(ServiceNowParams.SYSPARM_FIELDS, in)
                .query(ServiceNowParams.SYSPARM_INPUT_DISPLAY_VALUE, in)
                .query(ServiceNowParams.SYSPARM_SUPPRESS_AUTO_SYS_FIELD, in)
                .query(ServiceNowParams.SYSPARM_VIEW, in)
                .query(responseModel)
                .invoke(HttpMethod.POST, in.getMandatoryBody());

        setBodyAndHeaders(exchange.getIn(), responseModel, response);
    }

    public CamelMessageReceiver(GooglePubsubLiteConsumer consumer, GooglePubsubLiteEndpoint endpoint, Processor processor) {
        this.consumer = consumer;
        this.endpoint = endpoint;
        this.processor = processor;
        String loggerId = endpoint.getLoggerId();
        if (Strings.isNullOrEmpty(loggerId)) {
            loggerId = this.getClass().getName();
        }
        localLog = LoggerFactory.getLogger(loggerId);
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulPreparedQueryProducer target = (org.apache.camel.component.consul.endpoint.ConsulPreparedQueryProducer) obj;
        switch (key) {
        case "create":
        case "CREATE": target.create(exchange.getMessage()); return null;
        case "execute":
        case "EXECUTE": target.execute(exchange.getMessage()); return null;
        case "get":
        case "GET": target.get(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public JobResponse updateJobRetries(JobRequest message) {
        JobResponse resultMessage = new JobResponse();

        try {
            GatewayGrpc.GatewayBlockingStub stub = GatewayGrpc.newBlockingStub(managedChannel);
            GatewayOuterClass.UpdateJobRetriesRequest.Builder builder = GatewayOuterClass.UpdateJobRetriesRequest.newBuilder()
                    .setJobKey(message.getJobKey());
            builder = builder.setRetries(message.getRetries());
            GatewayOuterClass.UpdateJobRetriesRequest request = builder.build();
            GatewayOuterClass.UpdateJobRetriesResponse updateJobRetriesResponse = stub.updateJobRetries(request);

            resultMessage.setSuccess(true);
        } catch (StatusRuntimeException exception) {
            LOG.error(String.format("Cannot update retries for Job %s", message.getJobKey()), exception);
            resultMessage.setErrorMessage(exception.getMessage());
            resultMessage.setErrorCode(exception.getStatus().toString());
            resultMessage.setSuccess(false);
        }

        return resultMessage;
    }

    public void marshal(Exchange exchange, Object o, OutputStream outputStream) throws Exception {
        IBaseResource iBaseResource;
        if (!(o instanceof IBaseResource)) {
            iBaseResource = exchange.getContext().getTypeConverter().mandatoryConvertTo(IBaseResource.class, exchange, o);
        } else {
            iBaseResource = (IBaseResource) o;
        }

        IParser parser = getFhirContext().newXmlParser();
        configureParser(parser);
        parser.encodeResourceToWriter(iBaseResource, new OutputStreamWriter(outputStream));
        if (isContentTypeHeader()) {
            exchange.getMessage().setHeader(Exchange.CONTENT_TYPE, parser.getEncoding().getResourceContentTypeNonLegacy());
        }
    }

    protected boolean matchSecret(String name) {
        Set<String> set = new HashSet<>();
        if (secrets != null) {
            Collections.addAll(set, secrets.split(","));
        }

        for (String part : set) {
            boolean result = name.contains(part) || PatternHelper.matchPattern(name, part);
            LOG.trace("Matching secret id: {}={} -> {}", name, part, result);
            if (result) {
                return true;
            }
        }

        return false;
    }

    private boolean sendAsyncEvents(
            final Iterable<EventData> eventData, final SendOptions sendOptions, final Exchange exchange,
            final AsyncCallback asyncCallback) {
        sendAsyncEventsWithSuitableMethod(eventData, sendOptions)
                .subscribe(unused -> LOG.debug("Processed one event..."), error -> {
                     
                    LOG.debug("Error processing async exchange with error: {}", error.getMessage());
                    exchange.setException(error);
                    asyncCallback.done(false);
                }, () -> {
                     
                    LOG.debug("All events with exchange have been sent successfully.");
                    asyncCallback.done(false);
                });

        return false;
    }

    public static Expression collateExpression(final String expression, final int group) {
        return new ExpressionAdapter() {
            private Expression exp;

            @Override
            public void init(CamelContext context) {
                 
                exp = context.resolveLanguage("simple").createExpression(expression);
                exp.init(context);
                exp = ExpressionBuilder.groupIteratorExpression(exp, null, Integer.toString(group), false);
                exp.init(context);
            }

            @Override
            public Object evaluate(Exchange exchange) {
                return exp.evaluate(exchange, Object.class);
            }

            @Override
            public String toString() {
                return "collate(" + expression + "," + group + ")";
            }
        };
    }

    public InputLengthGuardrail(int maxChars, int minChars) {
        if (maxChars <= 0) {
            throw new IllegalArgumentException("maxChars must be positive");
        }
        if (minChars < 0) {
            throw new IllegalArgumentException("minChars cannot be negative");
        }
        if (minChars > maxChars) {
            throw new IllegalArgumentException("minChars cannot exceed maxChars");
        }
        this.maxChars = maxChars;
        this.minChars = minChars;
    }

    public void failedExchange(Exchange exchange) {
         
         
         
         
        UnitOfWork uow = exchange.getUnitOfWork();
        if (uow != null) {
            int level = uow.routeStackLevel(includeRouteTemplates, includeKamelets);
            if (level <= 1) {
                super.failedExchange(exchange);
                if (exchange.getFromEndpoint() != null && exchange.getFromEndpoint().isRemote()) {
                    remoteExchangesTotal.increment();
                    remoteExchangesFailed.increment();
                    remoteExchangesInflight.decrement();
                }
            }
        } else {
            super.failedExchange(exchange);
            if (exchange.getFromEndpoint() != null && exchange.getFromEndpoint().isRemote()) {
                remoteExchangesTotal.increment();
                remoteExchangesFailed.increment();
                remoteExchangesInflight.decrement();
            }
        }
    }

    private Object decodeWithAsymmetricKey(Exchange exchange, Document encodedDocument) throws Exception {

        if (keyStore == null && null != keyOrTrustStoreParameters) {
            keyStore = keyOrTrustStoreParameters.createKeyStore();
            keyStorePassword = keyOrTrustStoreParameters.getPassword();
        }

        if (this.keyStore == null) {
            throw new IllegalStateException("A key store must be defined for asymmetric key decryption.");
        }

        PrivateKey keyEncryptionKey = getPrivateKey(this.keyStore, this.recipientKeyAlias,
                this.keyPassword != null ? this.keyPassword : this.keyStorePassword);
        Object ret = null;
        try {
            ret = decode(exchange, encodedDocument, keyEncryptionKey, true);
        } catch (org.apache.xml.security.encryption.XMLEncryptionException ex) {
            if (ex.getMessage().equals("encryption.nokey")) {
                 
                ret = decode(exchange, encodedDocument, keyEncryptionKey, false);
            } else {
                throw ex;
            }
        }

         
        try {
            keyEncryptionKey.destroy();
        } catch (javax.security.auth.DestroyFailedException ex) {
            LOG.debug("Error destroying key: {}", ex.getMessage());
        }

        return ret;
    }

    private void doCreateOrUpdatePersistentVolumeClaim(
            Exchange exchange, String operationName,
            Function<Resource<PersistentVolumeClaim>, PersistentVolumeClaim> operation) {
        String pvcName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_PERSISTENT_VOLUME_CLAIM_NAME, String.class);
        String namespaceName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        PersistentVolumeClaimSpec pvcSpec = exchange.getIn()
                .getHeader(KubernetesConstants.KUBERNETES_PERSISTENT_VOLUME_CLAIM_SPEC, PersistentVolumeClaimSpec.class);
        if (ObjectHelper.isEmpty(pvcName)) {
            LOG.error("{} a specific Persistent Volume Claim require specify a Persistent Volume Claim name", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific Persistent Volume Claim require specify a Persistent Volume Claim name",
                            operationName));
        }
        if (ObjectHelper.isEmpty(namespaceName)) {
            LOG.error("{} a specific Persistent Volume Claim require specify a namespace name", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific Persistent Volume Claim require specify a namespace name", operationName));
        }
        if (ObjectHelper.isEmpty(pvcSpec)) {
            LOG.error("{} a specific Persistent Volume Claim require specify a Persistent Volume Claim spec bean",
                    operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific Persistent Volume Claim require specify a Persistent Volume Claim spec bean",
                            operationName));
        }
        Map<String, String> labels
                = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_PERSISTENT_VOLUMES_CLAIMS_LABELS, Map.class);
        PersistentVolumeClaim pvcCreating = new PersistentVolumeClaimBuilder().withNewMetadata().withName(pvcName)
                .withLabels(labels).endMetadata().withSpec(pvcSpec).build();
        PersistentVolumeClaim pvc
                = operation.apply(getEndpoint().getKubernetesClient().persistentVolumeClaims().inNamespace(namespaceName)
                        .resource(pvcCreating));

        prepareOutboundMessage(exchange, pvc);
    }

    public void process(Exchange exchange) {
        if (exchange.getIn().getBody() instanceof String) {
            String input = exchange.getIn().getBody(String.class);
            T result = predict(exchange, input);
            exchange.getIn().setBody(result);
        } else {
            throw new RuntimeCamelException("Data type is not supported. Body should be String");
        }
    }

    public static Method findMethod(Class<?> clazz, String name, Class<?>... paramTypes) {
        ObjectHelper.notNull(clazz, "Class must not be null");
        ObjectHelper.notNull(name, "Method name must not be null");
        Class<?> searchType = clazz;
        while (searchType != null) {
            Method[] methods = searchType.isInterface() ? searchType.getMethods() : searchType.getDeclaredMethods();
            for (Method method : methods) {
                if (name.equals(method.getName())
                        && (paramTypes == null || Arrays.equals(paramTypes, method.getParameterTypes()))) {
                    return method;
                }
            }
            searchType = searchType.getSuperclass();
        }
        return null;
    }

    private Charset getEncodingParameter(String type, MinaConfiguration configuration) {
        String encoding = configuration.getEncoding();
        if (encoding == null) {
            encoding = Charset.defaultCharset().name();
             
            configuration.setEncoding(encoding);
            LOG.debug("{}: No encoding parameter using default charset: {}", type, encoding);
        }
        if (!Charset.isSupported(encoding)) {
            throw new IllegalArgumentException("The encoding: " + encoding + " is not supported");
        }

        return Charset.forName(encoding);
    }

    private void updateResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String policyId = exchange.getIn().getHeader(KeycloakConstants.POLICY_ID, String.class);
        if (ObjectHelper.isEmpty(policyId)) {
            throw new IllegalArgumentException("Policy ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(policyId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Policy updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update policy requires POJO request with PolicyRepresentation");
        }
    }

    protected static AnnotationSpec yamlProperty(String name, String type, boolean required, boolean deprecated, String oneOf) {
        AnnotationSpec.Builder builder = AnnotationSpec.builder(CN_YAML_PROPERTY);
        builder.addMember("name", "$S", name);
        builder.addMember("type", "$S", type);
        if (required) {
            builder.addMember("required", "$L", required);
        }
        if (deprecated) {
            builder.addMember("deprecated", "$L", deprecated);
        }
        if (!Strings.isNullOrEmpty(oneOf)) {
            builder.addMember("oneOf", "$S", oneOf);
        }

        return builder.build();
    }

    public Olingo4AppWrapper createApiProxy(Olingo4Configuration endpointConfiguration) {
        final Olingo4AppWrapper result;
        if (endpointConfiguration.equals(getConfiguration())) {
            lock.lock();
            try {
                if (apiProxy == null) {
                    apiProxy = createOlingo4App(getConfiguration());
                }
            } finally {
                lock.unlock();
            }
            result = apiProxy;
        } else {
            result = createOlingo4App(endpointConfiguration);
        }
        return result;
    }

    public void process(Exchange exchange) throws Exception {

        Map<String, Object> headers = exchange.getIn().getHeaders();

         
        Object oid = null;

        if (headers.containsKey(HazelcastConstants.OBJECT_ID)) {
            oid = headers.get(HazelcastConstants.OBJECT_ID);
        }

        final HazelcastOperation operation = lookupOperation(exchange);

        switch (operation) {
            case PUT:
                this.put(oid, exchange);
                break;

            case GET:
                this.get(oid, exchange);
                break;

            case DELETE:
                this.delete(oid);
                break;

            case REMOVE_VALUE:
                this.removevalue(oid, exchange);
                break;

            case CONTAINS_KEY:
                this.containsKey(oid, exchange);
                break;

            case CONTAINS_VALUE:
                this.containsValue(exchange);
                break;

            case CLEAR:
                this.clear();
                break;

            case VALUE_COUNT:
                this.valuecount(oid, exchange);
                break;

            default:
                throw new IllegalArgumentException(
                        String.format("The value '%s' is not allowed for parameter '%s' on the MULTIMAP cache.", operation,
                                HazelcastConstants.OPERATION));
        }

         
        HazelcastComponentHelper.copyHeaders(exchange);
    }

    public static List<MethodInfo> methods(IndexView view, ClassInfo type, Predicate<MethodInfo> filter) {
        List<MethodInfo> answer = new ArrayList<>();

        for (ClassInfo current = type; current != null;) {
            for (MethodInfo methodInfo : current.methods()) {
                if (filter.test(methodInfo)) {
                    answer.add(methodInfo);
                }
            }

            Type superType = current.superClassType();
            if (superType == null) {
                break;
            }

            current = view.getClassByName(superType.name());
        }

        return answer;
    }

    private void runAsyncPush(Exchange exchange, Message message, DockerClient client) throws InterruptedException {
        try (PushImageCmd cmd = executePushImageRequest(client, message)) {
            Adapter<PushResponseItem> item = cmd.exec(new Adapter<PushResponseItem>() {
                @Override
                public void onNext(PushResponseItem item) {
                    super.onNext(item);

                    LOG.trace("push image callback {}", item);
                }
            });

            setResponse(exchange, item);
        }
    }

    protected final void process(final Object result) {
        Exchange exchange = createExchange(false);
        try {
            exchange.getIn().setBody(result);
            getProcessor().process(exchange);
        } catch (Exception e) {
            exchange.setException(e);
        }
        if (exchange.getException() != null) {
            getExceptionHandler().handleException("Error processing exchange", exchange, exchange.getException());
        }
        releaseExchange(exchange, false);
    }

    protected Configuration createConnectorConfiguration() {
        final Configuration.Builder configBuilder = Configuration.create();
        
        addPropertyIfNotNull(configBuilder, "transaction.metadata.factory", transactionMetadataFactory);
        addPropertyIfNotNull(configBuilder, "streaming.delay.ms", streamingDelayMs);
        addPropertyIfNotNull(configBuilder, "custom.metric.tags", customMetricTags);
        addPropertyIfNotNull(configBuilder, "mongodb.connection.string", mongodbConnectionString);
        addPropertyIfNotNull(configBuilder, "mongodb.password", mongodbPassword);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.job.namespace", openlineageIntegrationJobNamespace);
        addPropertyIfNotNull(configBuilder, "query.fetch.size", queryFetchSize);
        addPropertyIfNotNull(configBuilder, "signal.enabled.channels", signalEnabledChannels);
        addPropertyIfNotNull(configBuilder, "mongodb.ssl.enabled", mongodbSslEnabled);
        addPropertyIfNotNull(configBuilder, "cursor.max.await.time.ms", cursorMaxAwaitTimeMs);
        addPropertyIfNotNull(configBuilder, "field.renames", fieldRenames);
        addPropertyIfNotNull(configBuilder, "mongodb.server.selection.timeout.ms", mongodbServerSelectionTimeoutMs);
        addPropertyIfNotNull(configBuilder, "poll.interval.ms", pollIntervalMs);
        addPropertyIfNotNull(configBuilder, "guardrail.collections.max", guardrailCollectionsMax);
        addPropertyIfNotNull(configBuilder, "signal.data.collection", signalDataCollection);
        addPropertyIfNotNull(configBuilder, "converters", converters);
        addPropertyIfNotNull(configBuilder, "heartbeat.topics.prefix", heartbeatTopicsPrefix);
        addPropertyIfNotNull(configBuilder, "mongodb.connect.timeout.ms", mongodbConnectTimeoutMs);
        addPropertyIfNotNull(configBuilder, "snapshot.fetch.size", snapshotFetchSize);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.job.tags", openlineageIntegrationJobTags);
        addPropertyIfNotNull(configBuilder, "mongodb.poll.interval.ms", mongodbPollIntervalMs);
        addPropertyIfNotNull(configBuilder, "incremental.snapshot.watermarking.strategy", incrementalSnapshotWatermarkingStrategy);
        addPropertyIfNotNull(configBuilder, "mongodb.user", mongodbUser);
        addPropertyIfNotNull(configBuilder, "heartbeat.interval.ms", heartbeatIntervalMs);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.snapshot.on.schema.error", snapshotModeConfigurationBasedSnapshotOnSchemaError);
        addPropertyIfNotNull(configBuilder, "snapshot.collection.filter.overrides", snapshotCollectionFilterOverrides);
        addPropertyIfNotNull(configBuilder, "field.exclude.list", fieldExcludeList);
        addPropertyIfNotNull(configBuilder, "errors.max.retries", errorsMaxRetries);
        addPropertyIfNotNull(configBuilder, "database.exclude.list", databaseExcludeList);
        addPropertyIfNotNull(configBuilder, "max.batch.size", maxBatchSize);
        addPropertyIfNotNull(configBuilder, "skipped.operations", skippedOperations);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.job.description", openlineageIntegrationJobDescription);
        addPropertyIfNotNull(configBuilder, "topic.naming.strategy", topicNamingStrategy);
        addPropertyIfNotNull(configBuilder, "snapshot.mode", snapshotMode);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.snapshot.data", snapshotModeConfigurationBasedSnapshotData);
        addPropertyIfNotNull(configBuilder, "extended.headers.enabled", extendedHeadersEnabled);
        addPropertyIfNotNull(configBuilder, "max.queue.size", maxQueueSize);
        addPropertyIfNotNull(configBuilder, "guardrail.collections.limit.action", guardrailCollectionsLimitAction);
        addPropertyIfNotNull(configBuilder, "custom.sanitize.pattern", customSanitizePattern);
        addPropertyIfNotNull(configBuilder, "collection.include.list", collectionIncludeList);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.job.owners", openlineageIntegrationJobOwners);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.config.file.path", openlineageIntegrationConfigFilePath);
        addPropertyIfNotNull(configBuilder, "retriable.restart.connector.wait.ms", retriableRestartConnectorWaitMs);
        addPropertyIfNotNull(configBuilder, "capture.mode", captureMode);
        addPropertyIfNotNull(configBuilder, "snapshot.delay.ms", snapshotDelayMs);
        addPropertyIfNotNull(configBuilder, "executor.shutdown.timeout.ms", executorShutdownTimeoutMs);
        addPropertyIfNotNull(configBuilder, "provide.transaction.metadata", provideTransactionMetadata);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.snapshot.on.data.error", snapshotModeConfigurationBasedSnapshotOnDataError);
        addPropertyIfNotNull(configBuilder, "schema.history.internal.file.filename", schemaHistoryInternalFileFilename);
        addPropertyIfNotNull(configBuilder, "tombstones.on.delete", tombstonesOnDelete);
        addPropertyIfNotNull(configBuilder, "topic.prefix", topicPrefix);
        addPropertyIfNotNull(configBuilder, "sourceinfo.struct.maker", sourceinfoStructMaker);
        addPropertyIfNotNull(configBuilder, "mongodb.authsource", mongodbAuthsource);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.dataset.kafka.bootstrap.servers", openlineageIntegrationDatasetKafkaBootstrapServers);
        addPropertyIfNotNull(configBuilder, "collection.exclude.list", collectionExcludeList);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.enabled", openlineageIntegrationEnabled);
        addPropertyIfNotNull(configBuilder, "snapshot.include.collection.list", snapshotIncludeCollectionList);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.start.stream", snapshotModeConfigurationBasedStartStream);
        addPropertyIfNotNull(configBuilder, "max.queue.size.in.bytes", maxQueueSizeInBytes);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.snapshot.schema", snapshotModeConfigurationBasedSnapshotSchema);
        addPropertyIfNotNull(configBuilder, "signal.poll.interval.ms", signalPollIntervalMs);
        addPropertyIfNotNull(configBuilder, "post.processors", postProcessors);
        addPropertyIfNotNull(configBuilder, "notification.enabled.channels", notificationEnabledChannels);
        addPropertyIfNotNull(configBuilder, "mongodb.socket.timeout.ms", mongodbSocketTimeoutMs);
        addPropertyIfNotNull(configBuilder, "event.processing.failure.handling.mode", eventProcessingFailureHandlingMode);
        addPropertyIfNotNull(configBuilder, "snapshot.max.threads", snapshotMaxThreads);
        addPropertyIfNotNull(configBuilder, "notification.sink.topic.name", notificationSinkTopicName);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.custom.name", snapshotModeCustomName);
        addPropertyIfNotNull(configBuilder, "schema.name.adjustment.mode", schemaNameAdjustmentMode);
        addPropertyIfNotNull(configBuilder, "mongodb.ssl.invalid.hostname.allowed", mongodbSslInvalidHostnameAllowed);
        addPropertyIfNotNull(configBuilder, "mongodb.heartbeat.frequency.ms", mongodbHeartbeatFrequencyMs);
        addPropertyIfNotNull(configBuilder, "connection.validation.timeout.ms", connectionValidationTimeoutMs);
        addPropertyIfNotNull(configBuilder, "database.include.list", databaseIncludeList);
        
        return configBuilder.build();
    }

    protected void doInit() throws Exception {
        if (knownProperties == null || knownPrefixes == null) {
             
            EndpointUriFactory factory = getCamelContext().getCamelContextExtension().getEndpointUriFactory(getScheme());
            if (factory == null) {
                throw new IllegalStateException("Cannot find EndpointUriFactory for component: " + getScheme());
            }
            knownProperties = factory.propertyNames();
            knownPrefixes = factory.multiValuePrefixes();
        }
    }

    protected void doShutdown() throws Exception {
        ServiceHelper.stopAndShutdownService(map);

        if (scheduledExecutorService != null && stopScheduledExecutorService) {
            camelContext.getExecutorServiceManager().shutdown(scheduledExecutorService);
            scheduledExecutorService = null;
        }
        if (workerPool != null && stopWorkerPool) {
            camelContext.getExecutorServiceManager().shutdown(workerPool);
            workerPool = null;
        }
    }

    protected String predict(Exchange exchange, QAInput input) {
        Model model = exchange.getContext().getRegistry().lookupByNameAndType(modelName, Model.class);
        @SuppressWarnings("unchecked")
        Translator<QAInput, String> translator
                = exchange.getContext().getRegistry().lookupByNameAndType(translatorName, Translator.class);

        exchange.getIn().setHeader(DJLConstants.INPUT, input);
        try (Predictor<QAInput, String> predictor = model.newPredictor(translator)) {
            return predictor.predict(input);
        } catch (TranslateException e) {
            throw new RuntimeCamelException("Could not process input or output", e);
        }
    }

    public RestDefinition consumes(String mediaType) {
        if (getVerbs().isEmpty()) {
            this.consumes = mediaType;
        } else {
             
            VerbDefinition verb = getVerbs().get(getVerbs().size() - 1);
            verb.setConsumes(mediaType);
        }

        return this;
    }

    public Drive makeClient(
            String clientId, String clientSecret, Collection<String> scopes, String applicationName, String refreshToken,
            String accessToken) {
        if (clientId == null || clientSecret == null) {
            throw new IllegalArgumentException("clientId and clientSecret are required to create Google Drive client.");
        }
        try {
            Credential credential = authorize(clientId, clientSecret, scopes);

            if (refreshToken != null && !refreshToken.isEmpty()) {
                credential.setRefreshToken(refreshToken);
            }
            if (accessToken != null && !accessToken.isEmpty()) {
                credential.setAccessToken(accessToken);
            }
            return new Drive.Builder(transport, jsonFactory, credential).setApplicationName(applicationName).build();
        } catch (Exception e) {
            throw new RuntimeCamelException("Could not create Google Drive client.", e);
        }
    }

    public boolean process(final Exchange exchange, final AsyncCallback callback) {
         
        final Map<String, Object> properties = new HashMap<>(endpoint.getEndpointProperties());
        propertiesHelper.getExchangeProperties(exchange, properties);

         
        endpoint.interceptProperties(properties);
        interceptProperties(properties);

         
        properties.put(Olingo4Endpoint.RESPONSE_HANDLER_PROPERTY, new Olingo4ResponseHandler<Object>() {
            @Override
            public void onResponse(Object response, Map<String, String> responseHeaders) {
                if (resultIndex != null) {
                    response = resultIndex.filterResponse(response);
                }

                 
                 
                exchange.getOut().setBody(response);
                 
                exchange.getOut().setHeaders(exchange.getIn().getHeaders());

                 
                exchange.getOut().setHeader(Olingo4Constants.FULL_RESPONSE_HTTP_HEADERS, responseHeaders);

                interceptResult(response, exchange);

                callback.done(false);
            }

            @Override
            public void onException(Exception ex) {
                exchange.setException(ex);
                callback.done(false);
            }

            @Override
            public void onCanceled() {
                exchange.setException(new RuntimeCamelException("OData HTTP Request cancelled!"));
                callback.done(false);
            }
        });

         
        final ApiMethod method = findMethod(exchange, properties);
        if (method == null) {
             
            callback.done(true);
            return true;
        }

        if (LOG.isDebugEnabled()) {
            LOG.debug("Invoking operation {} with {}", method.getName(), properties.keySet());
        }

        try {
            doInvokeMethod(method, properties);
        } catch (Exception e) {
            exchange.setException(RuntimeCamelException.wrapRuntimeCamelException(e));
            callback.done(true);
            return true;
        }
        return false;

    }

    public Integer toInteger(JsonNode node, Exchange exchange) throws Exception {
        if (node instanceof NumericNode) {
            NumericNode nn = (NumericNode) node;
            if (nn.canConvertToInt()) {
                return nn.asInt();
            }
        }
        String text = node.asText();
        return Integer.valueOf(text);
    }

    private void deleteByIds(Exchange exchange) throws Exception {
        final Message in = exchange.getMessage();
        List elements = in.getMandatoryBody(List.class);
        String indexName = getEndpoint().getConfiguration().getIndexName();

        if (in.getHeader(PineconeVectorDbHeaders.INDEX_NAME, String.class) != null) {
            indexName = in.getHeader(PineconeVectorDbHeaders.INDEX_NAME, String.class);
        }

        Index index = this.client.getIndexConnection(indexName);

        DeleteResponse result
                = index.deleteByIds(elements);

        populateDeleteResponse(result, exchange);
    }

    public Processor createProcessor() throws Exception {
        if (definition.getVariables().isEmpty()) {
            throw new IllegalArgumentException("There must be at least one variable specified");
        }
        List<Expression> nameExprs = new java.util.ArrayList<>(definition.getVariables().size());
        List<Expression> valueExprs = new java.util.ArrayList<>(definition.getVariables().size());
        for (SetVariableDefinition varDef : definition.getVariables()) {
            valueExprs.add(createExpression(varDef.getExpression()));
            Expression nameExpr;
            String key = parseString(varDef.getName());
            if (LanguageSupport.hasSimpleFunction(key)) {
                nameExpr = camelContext.resolveLanguage("simple").createExpression(key);
            } else {
                nameExpr = camelContext.resolveLanguage("constant").createExpression(key);
            }
            nameExpr.init(camelContext);
            nameExprs.add(nameExpr);
        }

        SetVariablesProcessor answer = new SetVariablesProcessor(nameExprs, valueExprs);
        answer.setDisabled(isDisabled(camelContext, definition));
        return answer;
    }

    public String getDataFormatName() {
        if ("Csv".equals(type)) {
            return "bindyCsv";
        } else if ("Fixed".equals(type)) {
            return "bindyFixed";
        } else {
            return "bindyKvp";
        }
    }

    public Expression parseExpression() {
        try {
            parseTokens();
            return doParseExpression();
        } catch (SimpleParserException e) {
             
            throw new SimpleIllegalSyntaxException(expression, e.getIndex(), e.getMessage(), e);
        } catch (Exception e) {
             
            throw new SimpleIllegalSyntaxException(expression, -1, e.getMessage(), e);
        }
    }

    private boolean updateOptionsIn(final File file, final String kind, final String changed) throws MojoExecutionException {
        if (!file.exists()) {
            return false;
        }

        final String updated = changed.trim();
        try {
            String text = PackageHelper.loadText(file);

            String existing = Strings.between(text, "// " + kind + " options: START", "// " + kind + " options: END");
            if (existing != null) {
                 
                existing = existing.trim();
                if (existing.equals(updated)) {
                    return false;
                }

                String before = Strings.before(text, "// " + kind + " options: START");
                String after = Strings.after(text, "// " + kind + " options: END");
                text = before + "// " + kind + " options: START\n" + updated + "\n// " + kind + " options: END" + after;
                PackageHelper.writeText(file, text);
                return true;
            }

            getLog().warn("Cannot find markers in file " + file);
            getLog().warn("Add the following markers");
            getLog().warn("\t// " + kind + " options: START");
            getLog().warn("\t// " + kind + " options: END");
            if (isFailFast()) {
                throw new MojoExecutionException("Failed build due failFast=true");
            }
            return false;
        } catch (IOException e) {
            throw new MojoExecutionException("Error reading file " + file + " Reason: " + e, e);
        }
    }

    public boolean remove(final Exchange exchange, final String messageId) {
        final EntityManager entityManager
                = getTargetEntityManager(exchange, entityManagerFactory, true, sharedEntityManager, true);

        Boolean[] rc = new Boolean[1];
        transactionStrategy.executeInTransaction(() -> {
            if (isJoinTransaction()) {
                entityManager.joinTransaction();
            }
            try {
                List<?> list = query(entityManager, messageId);
                if (list.isEmpty()) {
                    rc[0] = Boolean.FALSE;
                } else {
                    MessageProcessed processed = (MessageProcessed) list.get(0);
                    entityManager.remove(processed);
                    entityManager.flush();
                    entityManager.close();
                    rc[0] = Boolean.TRUE;
                }
            } catch (Exception ex) {
                String contextInfo = String.format(SOMETHING_WENT_WRONG, ex.getMessage());
                throw new PersistenceException(contextInfo, ex);
            } finally {
                try {
                    if (entityManager.isOpen()) {
                        entityManager.close();
                    }
                } catch (Exception e) {
                     
                }
            }
        });

        LOG.debug("remove {}", messageId);
        return rc[0];
    }

    private void setupEventNotifierStrategies() {
        Map<String, EventNotifier> eventNotifiers = getContext().getRegistry().findByTypeWithName(EventNotifier.class);
        if (eventNotifiers != null && !eventNotifiers.isEmpty()) {
            for (Entry<String, EventNotifier> entry : eventNotifiers.entrySet()) {
                EventNotifier notifier = entry.getValue();
                 
                if (!getContext().getManagementStrategy().getEventNotifiers().contains(notifier)) {
                    LOG.info("Using custom EventNotifier with id: {} and implementation: {}", entry.getKey(), notifier);
                    getContext().getManagementStrategy().addEventNotifier(notifier);
                }
            }
        }
    }

    public static MainModel generateMainModel(JsonObject obj) {
        MainModel model = new MainModel();
        JsonArray mgrp = (JsonArray) obj.get("groups");
        for (Object entry : mgrp) {
            JsonObject mg = (JsonObject) entry;
            MainGroupModel group = new MainGroupModel();
            parseGroup(mg, group);
            model.addGroup(group);
        }
        JsonArray mprp = (JsonArray) obj.get("properties");
        for (Object entry : mprp) {
            JsonObject mp = (JsonObject) entry;
            MainOptionModel option = new MainOptionModel();
            parseOption(mp, option, mp.getString("name"));
            option.setSourceType(mp.getString("sourceType"));
            model.addOption(option);
        }
        return model;
    }

    protected final void process(final Object result) {
        Exchange exchange = createExchange(false);
        try {
            exchange.getIn().setBody(result);
            getProcessor().process(exchange);
        } catch (Exception e) {
            exchange.setException(e);
        }
        if (exchange.getException() != null) {
            getExceptionHandler().handleException("Error processing exchange", exchange, exchange.getException());
        }
        releaseExchange(exchange, false);
    }

    public static Method findMethod(Class<?> clazz, String name, Class<?>... paramTypes) {
        ObjectHelper.notNull(clazz, "Class must not be null");
        ObjectHelper.notNull(name, "Method name must not be null");
        Class<?> searchType = clazz;
        while (searchType != null) {
            Method[] methods = searchType.isInterface() ? searchType.getMethods() : searchType.getDeclaredMethods();
            for (Method method : methods) {
                if (name.equals(method.getName())
                        && (paramTypes == null || Arrays.equals(paramTypes, method.getParameterTypes()))) {
                    return method;
                }
            }
            searchType = searchType.getSuperclass();
        }
        return null;
    }

    public void parseArguments(String[] arguments) {
        LinkedList<String> args = new LinkedList<>(Arrays.asList(arguments));

        boolean valid = true;
        while (!args.isEmpty()) {
            initOptions();
            String arg = args.removeFirst();

            boolean handled = false;
            for (Option option : options) {
                if (option.processOption(arg, args)) {
                    handled = true;
                    break;
                }
            }
            if (!handled) {
                System.out.println("Unknown option: " + arg);
                System.out.println();
                valid = false;
                break;
            }
        }
        if (!valid) {
            showOptions();
            completed();
        }
    }

        public void release(final Exchange exchange) {
            semaphore.release();
            try {
                ScheduledFuture<?> next = asyncExecutor.schedule(this::clean, CLEAN_PERIOD, TimeUnit.MILLISECONDS);
                ScheduledFuture<?> prev = cleanFuture.getAndSet(next);
                if (prev != null) {
                    prev.cancel(false);
                }
                if (LOG.isTraceEnabled()) {
                    LOG.trace("Permit released, for exchangeId: {}", exchange.getExchangeId());
                }
            } catch (RejectedExecutionException e) {
                LOG.debug("Throttle cleaning rejected", e);
            }
        }

    public Processor createProcessor() throws Exception {
        ObjectHelper.notNull(definition.getPattern(), "patterns", definition);
        RemoveHeadersProcessor answer;
        if (definition.getExcludePatterns() != null) {
            answer = new RemoveHeadersProcessor(
                    parseString(definition.getPattern()), parseStrings(definition.getExcludePatterns()));
        } else if (definition.getExcludePattern() != null) {
            answer = new RemoveHeadersProcessor(
                    parseString(definition.getPattern()), parseStrings(new String[] { definition.getExcludePattern() }));
        } else {
            answer = new RemoveHeadersProcessor(parseString(definition.getPattern()), null);
        }
        answer.setDisabled(isDisabled(camelContext, definition));
        return answer;
    }

        protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
            doBeforeParse(element);
            super.doParse(element, parserContext, builder);

             
            Binder<Node> binder;
            try {
                binder = getJaxbContext().createBinder();
            } catch (JAXBException e) {
                throw new BeanDefinitionStoreException("Failed to create the JAXB binder", e);
            }
            Object value = parseUsingJaxb(element, parserContext, binder);

            if (value instanceof CamelEndpointFactoryBean) {
                CamelEndpointFactoryBean factoryBean = (CamelEndpointFactoryBean) value;
                builder.addPropertyValue("properties", factoryBean.getProperties());
            }
        }

    public String apply(String remainder) {
        String key = remainder;
        String defaultValue = null;

        if (remainder.contains(":")) {
            key = StringHelper.before(remainder, ":");
            defaultValue = StringHelper.after(remainder, ":");
        }

         
        if (key != null) {
             
            String host = IOHelper.lookupEnvironmentVariable(key + HOST_PREFIX);
            if (host != null) {
                return host;
            } else {
                return defaultValue;
            }
        }

        return defaultValue;
    }

    private void processUpsertSobject(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {
        String sObjectName = determineSObjectName(exchange);
        String sObjectExtIdValue;
        final String sObjectExtIdName = getParameter(SOBJECT_EXT_ID_NAME, exchange, IGNORE_BODY, NOT_OPTIONAL);

         
        Object oldValue = null;
        final AbstractSObjectBase sObjectBase = exchange.getIn().getBody(AbstractSObjectBase.class);
        if (sObjectBase != null) {
            oldValue = getAndClearPropertyValue(sObjectBase, sObjectExtIdName);
            sObjectExtIdValue = oldValue.toString();
             
            sObjectBase.clearBaseFields();
        } else {
            sObjectExtIdValue = getParameter(SOBJECT_EXT_ID_VALUE, exchange, IGNORE_BODY, NOT_OPTIONAL);
        }

        final Object finalOldValue = oldValue;
        restClient.upsertSObject(sObjectName, sObjectExtIdName, sObjectExtIdValue, determineHeaders(exchange),
                getRequestStream(exchange), new RestClient.ResponseCallback() {
                    @Override
                    public void onResponse(InputStream response, Map<String, String> headers, SalesforceException exception) {
                        restoreFields(exchange, sObjectBase, null, sObjectExtIdName, finalOldValue);
                        processResponse(exchange, response, headers, exception, callback);
                    }
                });
    }

    private void getVectors(S3VectorsClient client, Exchange exchange) {
        Message message = exchange.getIn();
        String vectorBucketName = determineVectorBucketName(exchange);
        String vectorIndexName = determineVectorIndexName(exchange);

         
        Object vectorIdsObj = message.getHeader(AWS2S3VectorsConstants.VECTOR_ID);
        if (vectorIdsObj == null) {
            vectorIdsObj = message.getBody();
        }

        List<String> vectorIds = convertToStringList(vectorIdsObj);

         
        GetVectorsRequest request = GetVectorsRequest.builder()
                .vectorBucketName(vectorBucketName)
                .indexName(vectorIndexName)
                .keys(vectorIds)
                .build();

        LOG.trace("Getting vectors [{}] from bucket [{}] index [{}]", vectorIds, vectorBucketName, vectorIndexName);
        GetVectorsResponse response = client.getVectors(request);
        LOG.trace("Get vectors response: {}", response);

        message.setBody(response.vectors());
    }

    private String getLoad(Row r) {
        String s1 = r.load01 != null ? r.load01 : "-";
        String s2 = r.load05 != null ? r.load05 : "-";
        String s3 = r.load15 != null ? r.load15 : "-";
        if ("0.00".equals(s1)) {
            s1 = "-";
        }
        if ("0.00".equals(s2)) {
            s2 = "-";
        }
        if ("0.00".equals(s3)) {
            s3 = "-";
        }
        if (s1.equals("-") && s2.equals("-") && s3.equals("-")) {
            return "0/0/0";
        }
        return s1 + "/" + s2 + "/" + s3;
    }

        protected void deliverToOnRedeliveryProcessor() {
            if (onRedeliveryProcessor == null) {
                return;
            }

            if (LOG.isTraceEnabled()) {
                LOG.trace("Redelivery processor {} is processing Exchange: {} before its redelivered",
                        onRedeliveryProcessor, exchange);
            }

             
            try {
                onRedeliveryProcessor.process(exchange);
            } catch (Exception e) {
                exchange.setException(e);
            }
            LOG.trace("Redelivery processor done");
        }

    public <T> void read(
            final Edm edm, final String resourcePath, final Map<String, String> queryParams,
            final Map<String, String> endpointHttpHeaders,
            final Olingo2ResponseHandler<T> responseHandler) {

        final UriInfoWithType uriInfo = parseUri(edm, resourcePath, queryParams);

        execute(new HttpGet(createUri(resourcePath, encodeQueryParams(queryParams))), getResourceContentType(uriInfo),
                endpointHttpHeaders,
                new AbstractFutureCallback<T>(responseHandler) {

                    @Override
                    public void onCompleted(HttpResponse result) throws IOException {
                        readContent(uriInfo, headersToMap(result.getAllHeaders()),
                                result.getEntity() != null ? result.getEntity().getContent() : null, responseHandler);
                    }

                });
    }

    private void insertMeasurement(Exchange exchange, String orgName, String bucketName, WritePrecision writePrecision)
            throws InvalidPayloadException {
        Measurement measurement = exchange.getIn().getMandatoryBody(Measurement.class);
        try {
            if (LOG.isDebugEnabled()) {
                LOG.debug("Writing measurement {}", measurement);
            }
            writeApi.writeMeasurement(bucketName, orgName, writePrecision, measurement.getInfluxMeasurement());
        } catch (Exception ex) {
            exchange.setException(new CamelInfluxDb2Exception(ex));
        }
    }

    protected String getSource(Annotation annotation) {
        String answer = null;
        try {
            answer = (String) getAnnotationObjectValue(annotation, "source");
        } catch (Exception e) {
             
        }
        if (answer != null && answer.isBlank()) {
            return null;
        }
        return answer;
    }

    protected void processStrategyRollback(
            GenericFileProcessStrategy<T> processStrategy, Exchange exchange, GenericFile<T> file) {

        if (LOG.isWarnEnabled()) {
            LOG.warn("Rollback file strategy: {} for file: {}", processStrategy, file);
        }

        if (Boolean.TRUE.equals(endpoint.isIdempotent())) {
             
             
            String key = absoluteFileName;
            if (endpoint.getIdempotentKey() != null) {
                Exchange dummy = GenericFileHelper.createDummy(endpoint, exchange, () -> file);
                key = endpoint.getIdempotentKey().evaluate(dummy, String.class);
            }
            if (key != null) {
                endpoint.getIdempotentRepository().remove(key);
            }
        }

         
         
         
        if (endpoint.getMoveFailed() != null) {
            handleDoneFile(exchange);
        }

        try {
            processStrategy.rollback(operations, endpoint, exchange, file);
        } catch (Exception e) {
            handleException("Error during rollback", exchange, e);
        }
    }

    public String apply(String remainder) {
        String key = remainder;
        String defaultValue = null;

        if (remainder.contains(":")) {
            key = StringHelper.before(remainder, ":");
            defaultValue = StringHelper.after(remainder, ":");
        }

         
        if (key != null) {
             
            String host = IOHelper.lookupEnvironmentVariable(key + HOST_PREFIX);
            if (host != null) {
                return host;
            } else {
                return defaultValue;
            }
        }

        return defaultValue;
    }

    private void getModel(Exchange exchange) {
        SpeechToText stt = getEndpoint().getSttClient();
        if (stt == null) {
            throw new IllegalStateException("STT client not initialized");
        }

        String modelName = exchange.getIn().getHeader(WatsonSpeechToTextConstants.MODEL_NAME, String.class);
        if (modelName == null) {
            modelName = exchange.getIn().getBody(String.class);
        }

        if (modelName == null || modelName.isBlank()) {
            throw new IllegalArgumentException("Model name must be specified");
        }

        LOG.trace("Getting model information for: {}", modelName);

        GetModelOptions options = new GetModelOptions.Builder()
                .modelId(modelName)
                .build();

        SpeechModel model = stt.getModel(options).execute().getResult();

        Message message = getMessageForResponse(exchange);
        message.setBody(model);
    }

    public static void parseXmlRouteSimpleExpressions(
            InputStream xml, String baseDir, String fullyQualifiedFileName,
            List<CamelSimpleExpressionDetails> simpleExpressions) {

         
         
        Document dom = getDocument(xml);
        if (dom != null) {
            List<Node> nodes = CamelXmlHelper.findAllLanguageExpressions(dom, "simple");
            for (Node node : nodes) {
                String simple = node.getTextContent();
                String lineNumber = (String) node.getUserData(XmlLineNumberParser.LINE_NUMBER);
                String lineNumberEnd = (String) node.getUserData(XmlLineNumberParser.LINE_NUMBER_END);

                String fileName = getFileName(baseDir, fullyQualifiedFileName);

                CamelSimpleExpressionDetails detail = new CamelSimpleExpressionDetails();
                detail.setFileName(fileName);
                detail.setLineNumber(lineNumber);
                detail.setLineNumberEnd(lineNumberEnd);
                detail.setSimple(simple);

                String column = (String) node.getUserData(XmlLineNumberParser.COLUMN_NUMBER);
                if (column != null) {
                    detail.setLinePosition(Integer.parseInt(column));
                }

                 
                boolean asPredicate = isSimplePredicate(node);
                detail.setPredicate(asPredicate);
                detail.setExpression(!asPredicate);

                simpleExpressions.add(detail);
            }
        }
    }

    public static AS2MessageDispositionNotificationEntity parseMessageDispositionNotificationEntityBody(
            AS2SessionInputBuffer inbuffer,
            InputStream is,
            String boundary,
            String charsetName)
            throws ParseException {
        CharsetDecoder previousDecoder = inbuffer.getCharsetDecoder();

        try {

            if (charsetName == null) {
                charsetName = StandardCharsets.US_ASCII.name();
            }
            Charset charset = Charset.forName(charsetName);
            CharsetDecoder charsetDecoder = charset.newDecoder();

            inbuffer.setCharsetDecoder(charsetDecoder);

            List<CharArrayBuffer> dispositionNotificationFields = parseBodyPartFields(inbuffer, is, boundary,
                    BasicLineParser.INSTANCE, new ArrayList<>());

            AS2MessageDispositionNotificationEntity as2MessageDispositionNotificationEntity
                    = DispositionNotificationContentUtils.parseDispositionNotification(dispositionNotificationFields);
            return as2MessageDispositionNotificationEntity;
        } catch (Exception e) {
            ParseException parseException = new ParseException("failed to parse MDN entity");
            parseException.initCause(e);
            throw parseException;
        } finally {
            inbuffer.setCharsetDecoder(previousDecoder);
        }
    }

    protected void doStart() throws Exception {
        super.doStart();
        if (getCamelContext() != null) {
            try {
                 
                getCamelContext().start();
            } finally {
                if (getCamelContext().isVetoStarted()) {
                    completed();
                }
            }
        }
    }

private int jjMoveStringLiteralDfa3_0(long old0, long active0){
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_0(1, old0);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(2, active0);
      return 3;
   }
   switch(curChar)
   {
      case 32:
         if ((active0 & 0x4L) != 0L)
            return jjStopAtPos(3, 2);
         break;
      case 85:
         return jjMoveStringLiteralDfa4_0(active0, 0x8L);
      default :
         break;
   }
   return jjStartNfa_0(2, active0);
}

    protected static List<String> getParameters(String path) {
        List<String> parameters = null;

        int startIndex = path.indexOf('{');
        while (startIndex != -1) {
            int endIndex = path.indexOf('}', startIndex);
            if (endIndex != -1) {
                if (parameters == null) {
                    parameters = new ArrayList<>();
                }
                parameters.add(path.substring(startIndex + 1, endIndex));
                startIndex = path.indexOf('{', endIndex);
            } else {
                 
                startIndex = -1;
            }
        }

        return parameters == null ? Collections.emptyList() : parameters;
    }

    protected void doStop() throws Exception {
        super.doStop();

        LOG.debug("Stopping Kubernetes Nodes Consumer");
        if (executor != null) {
            KubernetesHelper.close(nodesWatcher, nodesWatcher::getWatch);

            if (getEndpoint() != null && getEndpoint().getCamelContext() != null) {
                getEndpoint().getCamelContext().getExecutorServiceManager().shutdownNow(executor);
            } else {
                executor.shutdownNow();
            }
        }
        executor = null;
    }

    public void addConsumer(String key, DirectConsumer consumer) {
        consumersLock.lock();
        try {
            if (consumers.putIfAbsent(key, consumer) != null) {
                throw new IllegalArgumentException(
                        "Cannot add a 2nd consumer to the same endpoint: " + key
                                                   + ". DirectEndpoint only allows one consumer.");
            }
             
            stateCounter++;
            consumersCondition.signalAll();
        } finally {
            consumersLock.unlock();
        }
    }

    protected void doStop() throws Exception {
        super.doStop();
        localLog.info("Stopping Google PubSub Lite consumer for {}/{}", endpoint.getProjectId(), endpoint.getDestinationName());

        synchronized (subscribers) {
            if (!subscribers.isEmpty()) {
                localLog.info("Stopping subscribers for {}/{}", endpoint.getProjectId(), endpoint.getDestinationName());
                subscribers.forEach(Subscriber::stopAsync);
            }
        }

        if (executor != null) {
            if (getEndpoint() != null && getEndpoint().getCamelContext() != null) {
                getEndpoint().getCamelContext().getExecutorServiceManager().shutdownGraceful(executor);
            } else {
                executor.shutdownNow();
            }
        }
        executor = null;
    }

    public void process(Exchange exchange) throws Exception {
        String remotePath = DropboxHelper.getRemotePath(configuration, exchange);
        DropboxConfigurationValidator.validateGetOp(remotePath);

        DropboxFileDownloadResult result = new DropboxAPIFacade(configuration.getClient(), exchange)
                .get(remotePath);

        Map<String, Object> map = result.getEntries();
        if (map.size() == 1) {
            for (Map.Entry<String, Object> entry : map.entrySet()) {
                exchange.getIn().setHeader(DropboxConstants.DOWNLOADED_FILE, entry.getKey());
                exchange.getIn().setBody(entry.getValue());
            }
        } else {
            StringBuilder pathsExtracted = new StringBuilder();
            for (Map.Entry<String, Object> entry : map.entrySet()) {
                pathsExtracted.append(entry.getKey()).append('\n');
            }
            exchange.getIn().setHeader(DropboxConstants.DOWNLOADED_FILES, pathsExtracted.toString());
            exchange.getIn().setBody(map);
        }
        LOG.debug("Downloaded: {}", result);
    }

    private void updateResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String resourceId = exchange.getIn().getHeader(KeycloakConstants.RESOURCE_ID, String.class);
        if (ObjectHelper.isEmpty(resourceId)) {
            throw new IllegalArgumentException("Resource ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources().resource(resourceId)
                        .update((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Resource updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update resource requires POJO request with ResourceRepresentation");
        }
    }

                    protected void setValues(PreparedStatement ps, LobCreator lobCreator) throws SQLException {
                        int totalParameterIndex = 0;
                        lobCreator.setBlobAsBytes(ps, ++totalParameterIndex, data);
                        ps.setString(++totalParameterIndex, key);
                        ps.setLong(++totalParameterIndex, version);
                        if (storeBodyAsText) {
                            ps.setString(++totalParameterIndex, exchange.getIn().getBody(String.class));
                        }
                        if (hasHeadersToStoreAsText()) {
                            for (String headerName : headersToStoreAsText) {
                                String headerValue = exchange.getIn().getHeader(headerName, String.class);
                                ps.setString(++totalParameterIndex, headerValue);
                            }
                        }
                    }

    public static AS2MessageDispositionNotificationEntity parseMessageDispositionNotificationEntityBody(
            AS2SessionInputBuffer inbuffer,
            InputStream is,
            String boundary,
            String charsetName)
            throws ParseException {
        CharsetDecoder previousDecoder = inbuffer.getCharsetDecoder();

        try {

            if (charsetName == null) {
                charsetName = StandardCharsets.US_ASCII.name();
            }
            Charset charset = Charset.forName(charsetName);
            CharsetDecoder charsetDecoder = charset.newDecoder();

            inbuffer.setCharsetDecoder(charsetDecoder);

            List<CharArrayBuffer> dispositionNotificationFields = parseBodyPartFields(inbuffer, is, boundary,
                    BasicLineParser.INSTANCE, new ArrayList<>());

            AS2MessageDispositionNotificationEntity as2MessageDispositionNotificationEntity
                    = DispositionNotificationContentUtils.parseDispositionNotification(dispositionNotificationFields);
            return as2MessageDispositionNotificationEntity;
        } catch (Exception e) {
            ParseException parseException = new ParseException("failed to parse MDN entity");
            parseException.initCause(e);
            throw parseException;
        } finally {
            inbuffer.setCharsetDecoder(previousDecoder);
        }
    }

    public GoogleCalendarConfiguration getEndpointConfiguration(GoogleCalendarApiName apiName) {
        GoogleCalendarConfiguration result = null;
        switch (apiName) {
            case ACL:
                result = new CalendarAclEndpointConfiguration();
                break;
            case LIST:
                result = new CalendarCalendarListEndpointConfiguration();
                break;
            case CALENDARS:
                result = new CalendarCalendarsEndpointConfiguration();
                break;
            case CHANNELS:
                result = new CalendarChannelsEndpointConfiguration();
                break;
            case COLORS:
                result = new CalendarColorsEndpointConfiguration();
                break;
            case FREEBUSY:
                result = new CalendarFreebusyEndpointConfiguration();
                break;
            case EVENTS:
                result = new CalendarEventsEndpointConfiguration();
                break;
            case SETTINGS:
                result = new CalendarSettingsEndpointConfiguration();
                break;
        }
        return result;
    }

    public static Predicate or(final Predicate left, final Predicate right) {
        notNull(left, "left");
        notNull(right, "right");
        return new Predicate() {
            public boolean matches(Exchange exchange) {
                return left.matches(exchange) || right.matches(exchange);
            }

            @Override
            public void init(CamelContext camelContext) {
                left.initPredicate(camelContext);
                right.initPredicate(camelContext);
            }

            @Override
            public String toString() {
                return "(" + left + ") or (" + right + ")";
            }
        };
    }

    private void setAdditionalConfiguration(RestConfiguration config, String prefix, PropertyBindingSupport.Builder builder) {
        if (config.getDataFormatProperties() != null && !config.getDataFormatProperties().isEmpty()) {
             
             
            Map<String, Object> copy = new HashMap<>();

             
             
             
            for (Map.Entry<String, Object> entry : config.getDataFormatProperties().entrySet()) {
                String key = entry.getKey();
                String copyKey;
                boolean known = isKeyKnownPrefix(key);
                if (known) {
                     
                    copyKey = key.substring(prefix.length());
                } else {
                     
                    copyKey = key;
                }
                if (!known || key.startsWith(prefix)) {
                    copy.put(copyKey, entry.getValue());
                }
            }

            builder.withProperties(copy);
        }
    }

    private static GenericFileExclusiveReadLockStrategy<File> newStrategyForIdempotent(
            Map<String, Object> params) {
        GenericFileExclusiveReadLockStrategy<File> strategy;
        FileIdempotentRepositoryReadLockStrategy readLockStrategy = new FileIdempotentRepositoryReadLockStrategy();
        Boolean readLockRemoveOnRollback = (Boolean) params.get("readLockRemoveOnRollback");
        if (readLockRemoveOnRollback != null) {
            readLockStrategy.setRemoveOnRollback(readLockRemoveOnRollback);
        }
        Boolean readLockRemoveOnCommit = (Boolean) params.get("readLockRemoveOnCommit");
        if (readLockRemoveOnCommit != null) {
            readLockStrategy.setRemoveOnCommit(readLockRemoveOnCommit);
        }
        IdempotentRepository repo = (IdempotentRepository) params.get("readLockIdempotentRepository");
        if (repo != null) {
            readLockStrategy.setIdempotentRepository(repo);
        }
        Integer readLockIdempotentReleaseDelay = (Integer) params.get("readLockIdempotentReleaseDelay");
        if (readLockIdempotentReleaseDelay != null) {
            readLockStrategy.setReadLockIdempotentReleaseDelay(readLockIdempotentReleaseDelay);
        }
        Boolean readLockIdempotentReleaseAsync = (Boolean) params.get("readLockIdempotentReleaseAsync");
        if (readLockIdempotentReleaseAsync != null) {
            readLockStrategy.setReadLockIdempotentReleaseAsync(readLockIdempotentReleaseAsync);
        }
        Integer readLockIdempotentReleaseAsyncPoolSize = (Integer) params.get("readLockIdempotentReleaseAsyncPoolSize");
        if (readLockIdempotentReleaseAsyncPoolSize != null) {
            readLockStrategy.setReadLockIdempotentReleaseAsyncPoolSize(readLockIdempotentReleaseAsyncPoolSize);
        }
        ScheduledExecutorService readLockIdempotentReleaseExecutorService
                = (ScheduledExecutorService) params.get("readLockIdempotentReleaseExecutorService");
        if (readLockIdempotentReleaseExecutorService != null) {
            readLockStrategy.setReadLockIdempotentReleaseExecutorService(readLockIdempotentReleaseExecutorService);
        }
        strategy = readLockStrategy;
        return strategy;
    }

    private ClientConfigurations initializeConfigurations(ImageRecognitionEndpoint endpoint) {
        ClientConfigurations clientConfigurations = new ClientConfigurations();

        clientConfigurations.setAccessKey(getAccessKey(endpoint));
        clientConfigurations.setSecretKey(getSecretKey(endpoint));
        clientConfigurations.setProjectId(getProjectId(endpoint));
        clientConfigurations.setEndpoint(getEndpoint(endpoint));

        clientConfigurations.setIgnoreSslVerification(endpoint.isIgnoreSslVerification());
        if (clientConfigurations.isIgnoreSslVerification()) {
            LOG.warn("SSL verification is ignored. This is unsafe in production environment");
        }
        if (!StringUtils.isEmpty(endpoint.getProxyHost())) {
            clientConfigurations.setProxyHost(endpoint.getProxyHost());
            clientConfigurations.setProxyPort(endpoint.getProxyPort());
            clientConfigurations.setProxyUser(endpoint.getProxyUser());
            clientConfigurations.setProxyPassword(endpoint.getProxyPassword());
        }
        return clientConfigurations;
    }

    public V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
        if (key == null || remappingFunction == null) {
            throw new NullPointerException();
        }
        for (;;) {
            SoftReference<V> ref = delegate.get(key);
            V oldValue = ref == null ? null : ref.get();
            V newValue = remappingFunction.apply(key, oldValue);
            if (newValue == null) {
                 
                if (ref != null && !delegate.remove(key, ref)) {
                     
                    continue;
                }
            } else if (ref == null) {
                if (delegate.putIfAbsent(key, new SoftReference<>(newValue)) != null) {
                     
                    continue;
                }
            } else if (!delegate.replace(key, ref, new SoftReference<>(newValue))) {
                 
                continue;
            }
            return newValue;
        }
    }

    public static String resolveCamelVersionFromSpringBoot(String repos, String camelSpringBootVersion, boolean download)
            throws Exception {
        DependencyDownloaderClassLoader cl = new DependencyDownloaderClassLoader(CatalogLoader.class.getClassLoader());
        MavenDependencyDownloader downloader = new MavenDependencyDownloader();
        downloader.setRepositories(repos);
        downloader.setClassLoader(cl);
        downloader.setDownload(download);
        try {
            downloader.start();

            List<MavenArtifact> artifacts
                    = downloader.downloadArtifacts("org.apache.camel.springboot", "camel-catalog-provider-springboot",
                            camelSpringBootVersion, true);
            for (MavenArtifact ma : artifacts) {
                String g = ma.getGav().getGroupId();
                String a = ma.getGav().getArtifactId();
                if ("org.apache.camel".equals(g) && "camel-catalog".equals(a)) {
                    return ma.getGav().getVersion();
                }
            }
        } finally {
            downloader.stop();
            downloader.close();
        }

        return null;
    }

    public TabularData extendedInformation() {
        try {
            TabularData answer = new TabularDataSupport(CamelOpenMBeanTypes.endpointsUtilizationTabularType());

            EndpointUtilizationStatistics stats = getProcessor().getEndpointUtilizationStatistics();
            if (stats != null) {
                for (Map.Entry<String, Long> entry : stats.getStatistics().entrySet()) {
                    CompositeType ct = CamelOpenMBeanTypes.endpointsUtilizationCompositeType();
                    String url = entry.getKey();
                    if (sanitize) {
                        url = URISupport.sanitizeUri(url);
                    }

                    Long hits = entry.getValue();
                    if (hits == null) {
                        hits = 0L;
                    }

                    CompositeData data
                            = new CompositeDataSupport(ct, new String[] { "url", "hits" }, new Object[] { url, hits });
                    answer.put(data);
                }
            }
            return answer;
        } catch (Exception e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        }
    }

    public Producer createProducer() throws Exception {
        if (metricsType == MetricsType.COUNTER) {
            return new CounterProducer(this);
        } else if (metricsType == MetricsType.HISTOGRAM) {
            return new HistogramProducer(this);
        } else if (metricsType == MetricsType.METER) {
            return new MeterProducer(this);
        } else if (metricsType == MetricsType.TIMER) {
            return new TimerProducer(this);
        } else if (metricsType == MetricsType.GAUGE) {
            return new GaugeProducer(this);
        } else {
            throw new IllegalArgumentException("Metrics type " + metricsType + " is not supported");
        }
    }

    public void removeConsumer(String key, DirectConsumer consumer) {
        consumersLock.lock();
        try {
            consumers.remove(key, consumer);
             
            stateCounter++;
            consumersCondition.signalAll();
        } finally {
            consumersLock.unlock();
        }
    }

    protected void doScaleDeployment(Exchange exchange) {
        String deploymentName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_DEPLOYMENT_NAME, String.class);
        String namespaceName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        Integer replicasNumber = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_DEPLOYMENT_REPLICAS, Integer.class);
        if (ObjectHelper.isEmpty(deploymentName)) {
            LOG.error("Scale a specific deployment require specify a deployment name");
            throw new IllegalArgumentException("Scale a specific deployment require specify a deployment name");
        }
        if (ObjectHelper.isEmpty(namespaceName)) {
            LOG.error("Scale a specific deployment require specify a namespace name");
            throw new IllegalArgumentException("Scale a specific deployment require specify a namespace name");
        }
        if (ObjectHelper.isEmpty(replicasNumber)) {
            LOG.error("Scale a specific deployment require specify a replicas number");
            throw new IllegalArgumentException("Scale a specific deployment require specify a replicas number");
        }
        Deployment deploymentScaled = getEndpoint().getKubernetesClient().apps().deployments().inNamespace(namespaceName)
                .withName(deploymentName).scale(replicasNumber);

        prepareOutboundMessage(exchange, deploymentScaled.getStatus().getReplicas());
    }

        public void run() {
            FilterWatchListDeletable<DeploymentConfig, DeploymentConfigList, DeployableScalableResource<DeploymentConfig>> w;

             
            String namespace = getEndpoint().getKubernetesConfiguration().getNamespace();
            String labelKey = getEndpoint().getKubernetesConfiguration().getLabelKey();
            String labelValue = getEndpoint().getKubernetesConfiguration().getLabelValue();
            String resourceName = getEndpoint().getKubernetesConfiguration().getResourceName();

            if (ObjectHelper.isEmpty(namespace)) {
                w = getEndpoint().getKubernetesClient().adapt(OpenShiftClient.class).deploymentConfigs().inAnyNamespace();

                if (ObjectHelper.isNotEmpty(labelKey) && ObjectHelper.isNotEmpty(labelValue)) {
                    w = w.withLabel(labelKey, labelValue);
                }
            } else {
                final NonNamespaceOperation<DeploymentConfig, DeploymentConfigList, DeployableScalableResource<DeploymentConfig>> client
                        = getEndpoint().getKubernetesClient().adapt(OpenShiftClient.class).deploymentConfigs()
                                .inNamespace(namespace);
                w = client;
                if (ObjectHelper.isNotEmpty(labelKey) && ObjectHelper.isNotEmpty(labelValue)) {
                    w = client.withLabel(labelKey, labelValue);
                } else if (ObjectHelper.isNotEmpty(resourceName)) {
                    w = (FilterWatchListDeletable<DeploymentConfig, DeploymentConfigList, DeployableScalableResource<DeploymentConfig>>) client
                            .withName(resourceName);
                }
            }

            watch = w.watch(new Watcher<>() {

                @Override
                public void eventReceived(Action action, DeploymentConfig resource) {
                    DeploymentConfigEvent de = new DeploymentConfigEvent(action, resource);
                    Exchange exchange = createExchange(false);
                    exchange.getIn().setBody(de.getDeploymentConfig());
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_ACTION, de.getAction());
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_TIMESTAMP, System.currentTimeMillis());
                    try {
                        processor.process(exchange);
                    } catch (Exception e) {
                        getExceptionHandler().handleException("Error during processing", exchange, e);
                    } finally {
                        releaseExchange(exchange, false);
                    }
                }

                @Override
                public void onClose(WatcherException cause) {
                    if (cause != null) {
                        LOG.error(cause.getMessage(), cause);
                    }

                }
            });
        }

    protected <T> T cache(String name, Supplier<T> loader) {
        if (caching) {
            T t = (T) cache.get(name);
            if (t == null) {
                t = loader.get();
                if (t != null) {
                    cache.put(name, t);
                }
            }
            return t;
        } else {
            return loader.get();
        }
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        boolean cache = getAndRemoveParameter(parameters, "contentCache", Boolean.class, contentCache);

        JsltEndpoint answer = new JsltEndpoint(uri, this, remaining);
        answer.setContentCache(cache);
        answer.setAllowTemplateFromHeader(allowTemplateFromHeader);
        setProperties(answer, parameters);

         
        if (ResourceHelper.isHttpUri(remaining)) {
            remaining = ResourceHelper.appendParameters(remaining, parameters);
            answer.setResourceUri(remaining);
        }

        return answer;
    }

        protected void deliverToOnRedeliveryProcessor() {
            if (onRedeliveryProcessor == null) {
                return;
            }

            if (LOG.isTraceEnabled()) {
                LOG.trace("Redelivery processor {} is processing Exchange: {} before its redelivered",
                        onRedeliveryProcessor, exchange);
            }

             
            try {
                onRedeliveryProcessor.process(exchange);
            } catch (Exception e) {
                exchange.setException(e);
            }
            LOG.trace("Redelivery processor done");
        }

    public void failedExchange(Exchange exchange) {
         
         
         
         
        UnitOfWork uow = exchange.getUnitOfWork();
        if (uow != null) {
            int level = uow.routeStackLevel(includeRouteTemplates, includeKamelets);
            if (level <= 1) {
                super.failedExchange(exchange);
                if (exchange.getFromEndpoint() != null && exchange.getFromEndpoint().isRemote()) {
                    remoteExchangesTotal.increment();
                    remoteExchangesFailed.increment();
                    remoteExchangesInflight.decrement();
                }
            }
        } else {
            super.failedExchange(exchange);
            if (exchange.getFromEndpoint() != null && exchange.getFromEndpoint().isRemote()) {
                remoteExchangesTotal.increment();
                remoteExchangesFailed.increment();
                remoteExchangesInflight.decrement();
            }
        }
    }

    public Exchange createCopy(Exchange exchange) {
        Exchange answer = pool.poll();
        if (answer == null) {
            if (statisticsEnabled) {
                statistics.created.increment();
            }
             
            answer = new DefaultPooledExchange(exchange);
        } else {
            if (statisticsEnabled) {
                statistics.acquired.increment();
            }
        }

         
        ((ResetableClock) exchange.getClock()).reset();
        ExchangeHelper.copyResults(answer, exchange);
        return answer;
    }

    private void processAbortJob(Exchange exchange, AsyncCallback callback)
            throws SalesforceException {
        String jobId = getParameter(JOB_ID, exchange, IGNORE_BODY, NOT_OPTIONAL);
        bulkClient.changeJobState(jobId, JobStateEnum.ABORTED, determineHeaders(exchange),
                new JobResponseCallback() {
                    @Override
                    public void onResponse(Job job, Map<String, String> headers, SalesforceException ex) {
                        processResponse(exchange, job, headers, ex, callback);
                    }
                });
    }

    public KeyPair rotateKey(String oldKeyId, String newKeyId, String algorithm) throws Exception {
        LOG.info("Rotating key from {} to {}", oldKeyId, newKeyId);

         
        KeyMetadata oldMetadata = getKeyMetadata(oldKeyId);
        if (oldMetadata == null) {
            throw new IllegalArgumentException("Old key not found: " + oldKeyId);
        }

         
        oldMetadata.setStatus(KeyMetadata.KeyStatus.DEPRECATED);
        updateKeyMetadata(oldKeyId, oldMetadata);

         
        KeyPair newKeyPair = generateKeyPair(algorithm, newKeyId);

        LOG.info("Key rotation completed in AWS Secrets Manager: {} -> {}", oldKeyId, newKeyId);
        return newKeyPair;
    }

    protected void doListServiceByLabels(Exchange exchange) {
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        Map<String, String> labels = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_SERVICE_LABELS, Map.class);
        ServiceList servicesList;

        if (ObjectHelper.isEmpty(labels)) {
            LOG.error("Listing Services by labels requires specifying labels");
            throw new IllegalArgumentException("Listing Services by labels requires specifying labels");
        }

        if (ObjectHelper.isEmpty(namespace)) {
            servicesList = getEndpoint().getKubernetesClient().services().inAnyNamespace().withLabels(labels).list();
        } else {
            servicesList = getEndpoint().getKubernetesClient().services().inNamespace(namespace).withLabels(labels).list();
        }

        prepareOutboundMessage(exchange, servicesList.getItems());
    }

    private void updateGroup(Exchange exchange, ClientConfigurations clientConfigurations) {
         
        Object body = exchange.getMessage().getBody();
        KeystoneUpdateGroupOption groupOption;
        if (body instanceof KeystoneUpdateGroupOption) {
            groupOption = (KeystoneUpdateGroupOption) body;
        } else if (body instanceof String) {
            String strBody = (String) body;
            try {
                groupOption = new ObjectMapper().readValue(strBody, KeystoneUpdateGroupOption.class);
            } catch (JsonProcessingException e) {
                throw new IllegalArgumentException("String request body must be a valid JSON with the proper keys");
            }
        } else {
            throw new IllegalArgumentException(
                    "Exchange body is mandatory and should be a valid JSON string or KeystoneUpdateGroupOption object");
        }

         
        if (ObjectHelper.isEmpty(clientConfigurations.getGroupId())) {
            if (LOG.isErrorEnabled()) {
                LOG.error("No group id given");
            }
            throw new IllegalArgumentException("Group id is mandatory to update group");
        }

         
        KeystoneUpdateGroupRequestBody requestBody = new KeystoneUpdateGroupRequestBody()
                .withGroup(groupOption);
        KeystoneUpdateGroupRequest request = new KeystoneUpdateGroupRequest()
                .withBody(requestBody)
                .withGroupId(clientConfigurations.getGroupId());
        KeystoneUpdateGroupResponse response = iamClient.keystoneUpdateGroup(request);
        exchange.getMessage().setBody(gson.toJson(response.getGroup()));
    }

    protected void doList(Exchange exchange) {
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        JobList jobList;

        if (ObjectHelper.isEmpty(namespace)) {
            jobList = getEndpoint().getKubernetesClient().batch().v1().jobs().inAnyNamespace().list();
        } else {
            jobList = getEndpoint().getKubernetesClient().batch().v1().jobs().inNamespace(namespace).list();
        }

        prepareOutboundMessage(exchange, jobList.getItems());
    }

    private Document createDocumentFromExchange(Exchange exchange) throws InvalidPayloadException {
         
        String s3Bucket = getConfiguration().getS3Bucket();
        String s3Object = getConfiguration().getS3Object();

        if (ObjectHelper.isEmpty(s3Bucket)) {
            s3Bucket = exchange.getIn().getHeader(Textract2Constants.S3_BUCKET, String.class);
        }
        if (ObjectHelper.isEmpty(s3Object)) {
            s3Object = exchange.getIn().getHeader(Textract2Constants.S3_OBJECT, String.class);
        }

        if (ObjectHelper.isNotEmpty(s3Bucket) && ObjectHelper.isNotEmpty(s3Object)) {
            S3Object.Builder s3ObjectBuilder = S3Object.builder()
                    .bucket(s3Bucket)
                    .name(s3Object);

            String s3ObjectVersion = getConfiguration().getS3ObjectVersion();
            if (ObjectHelper.isEmpty(s3ObjectVersion)) {
                s3ObjectVersion = exchange.getIn().getHeader(Textract2Constants.S3_OBJECT_VERSION, String.class);
            }
            if (ObjectHelper.isNotEmpty(s3ObjectVersion)) {
                s3ObjectBuilder.version(s3ObjectVersion);
            }

            return Document.builder()
                    .s3Object(s3ObjectBuilder.build())
                    .build();
        } else {
             
            byte[] documentBytes = exchange.getIn().getMandatoryBody(byte[].class);
            return Document.builder()
                    .bytes(SdkBytes.fromByteArray(documentBytes))
                    .build();
        }
    }

    private void setupCommonServices() throws Exception {
        BacklogTracer backlogTracer = getBeanForType(BacklogTracer.class);
        if (backlogTracer != null) {
            LOG.info("Using custom BacklogTracer: {}", backlogTracer);
            getContext().addService(backlogTracer);
        }
        InflightRepository inflightRepository = getBeanForType(InflightRepository.class);
        if (inflightRepository != null) {
            LOG.info("Using custom InflightRepository: {}", inflightRepository);
            getContext().setInflightRepository(inflightRepository);
        }
        AsyncProcessorAwaitManager asyncProcessorAwaitManager = getBeanForType(AsyncProcessorAwaitManager.class);
        if (asyncProcessorAwaitManager != null) {
            LOG.info("Using custom AsyncProcessorAwaitManager: {}", asyncProcessorAwaitManager);
            getContext().getCamelContextExtension().addContextPlugin(AsyncProcessorAwaitManager.class,
                    asyncProcessorAwaitManager);
        }
        ManagementStrategy managementStrategy = getBeanForType(ManagementStrategy.class);
        if (managementStrategy != null) {
            LOG.info("Using custom ManagementStrategy: {}", managementStrategy);
            getContext().setManagementStrategy(managementStrategy);
        }
        ManagementObjectNameStrategy managementObjectNameStrategy = getBeanForType(ManagementObjectNameStrategy.class);
        if (managementObjectNameStrategy != null) {
            LOG.info("Using custom ManagementObjectNameStrategy: {}", managementObjectNameStrategy);
            getContext().getManagementStrategy().setManagementObjectNameStrategy(managementObjectNameStrategy);
        }
        EventFactory eventFactory = getBeanForType(EventFactory.class);
        if (eventFactory != null) {
            LOG.info("Using custom EventFactory: {}", eventFactory);
            getContext().getManagementStrategy().setEventFactory(eventFactory);
        }
        UnitOfWorkFactory unitOfWorkFactory = getBeanForType(UnitOfWorkFactory.class);
        if (unitOfWorkFactory != null) {
            LOG.info("Using custom UnitOfWorkFactory: {}", unitOfWorkFactory);
            getContext().getCamelContextExtension().addContextPlugin(UnitOfWorkFactory.class, unitOfWorkFactory);
        }
        RuntimeEndpointRegistry runtimeEndpointRegistry = getBeanForType(RuntimeEndpointRegistry.class);
        if (runtimeEndpointRegistry != null) {
            LOG.info("Using custom RuntimeEndpointRegistry: {}", runtimeEndpointRegistry);
            getContext().setRuntimeEndpointRegistry(runtimeEndpointRegistry);
        }
        EndpointServiceRegistry endpointServiceRegistry = getBeanForType(EndpointServiceRegistry.class);
        if (endpointServiceRegistry != null) {
            LOG.info("Using custom EndpointServiceRegistry: {}", endpointServiceRegistry);
            getContext().getCamelContextExtension().addContextPlugin(EndpointServiceRegistry.class, endpointServiceRegistry);
        }
        HeadersMapFactory headersMapFactory = getBeanForType(HeadersMapFactory.class);
        if (headersMapFactory != null) {
            LOG.info("Using custom HeadersMapFactory: {}", headersMapFactory);
            getContext().getCamelContextExtension().setHeadersMapFactory(headersMapFactory);
        }
    }

    private CamelLogger resolveLogger(TransactionErrorHandlerDefinition definition) {
        CamelLogger answer = definition.getLoggerBean();
        if (answer == null && definition.getLoggerRef() != null) {
            answer = mandatoryLookup(definition.getLoggerRef(), CamelLogger.class);
        }
        if (answer == null) {
            answer = new CamelLogger(LoggerFactory.getLogger(TransactionErrorHandler.class), LoggingLevel.ERROR);
        }
        if (definition.getLevel() != null) {
            answer.setLevel(parse(LoggingLevel.class, definition.getLevel()));
        }
        return answer;
    }

    private DaprOperationResponse waitForInstanceStart(Exchange exchange, DaprWorkflowClient client) {
        String instanceId = configurationOptionsProxy.getWorkflowInstanceId(exchange);
        Duration timeout = configurationOptionsProxy.getTimeout(exchange);
        boolean getWorkflowIO = configurationOptionsProxy.getWorkflowIO(exchange);

        try {
            WorkflowInstanceStatus response = client.waitForInstanceStart(instanceId, timeout, getWorkflowIO);
            return DaprOperationResponse.createFromWorkflowStatus(response);
        } catch (TimeoutException exception) {
            throw new RuntimeCamelException(
                    "Workflow instance " + instanceId + " could not be started in " + timeout, exception);
        }
    }

    public String apply(String remainder) {
        String key = remainder;
        String defaultValue = null;

        if (remainder.contains(":")) {
            key = StringHelper.before(remainder, ":");
            defaultValue = StringHelper.after(remainder, ":");
        }

         
        if (key != null) {
             
            key = key.toUpperCase(Locale.ENGLISH).replace('-', '_');

             
            String host = IOHelper.lookupEnvironmentVariable(key + HOST_PREFIX);
            String port = IOHelper.lookupEnvironmentVariable(key + PORT_PREFIX);

            if (host != null && port != null) {
                return host + ":" + port;
            } else {
                return defaultValue;
            }
        }

        return defaultValue;
    }

    private String getUri(Row r) {
        String u = r.uri;
        if (shortUri) {
            int pos = u.indexOf('?');
            if (pos > 0) {
                u = u.substring(0, pos);
            }
        }
        return u;
    }

    private <T> T unmarshalResponse(InputStream response, Request request, TypeReference<T> typeRef)
            throws SalesforceException {
        T result = null;
        if (response != null) {
            try {
                result = objectMapper.readValue(response, typeRef);
            } catch (IOException e) {
                throw new SalesforceException(
                        String.format("Error unmarshalling response for {%s:%s} : %s",
                                request.getMethod(), request.getURI(), e.getMessage()),
                        e);
            }
        }
        return result;
    }

    public Integer doProcessWatchCall() throws Exception {
        List<Row> rows = new ArrayList<>();

        List<Long> pids = findPids(name);
        ProcessHandle.allProcesses()
                .filter(ph -> pids.contains(ph.pid()))
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                     
                    if (root != null) {
                        Row row = new Row();
                        JsonObject context = (JsonObject) root.get("context");
                        if (context == null) {
                            return;
                        }
                        row.name = context.getString("name");
                        if ("CamelJBang".equals(row.name)) {
                            row.name = ProcessHelper.extractName(root, ph);
                        }
                        row.pid = Long.toString(ph.pid());
                        row.uptime = extractSince(ph);
                        row.age = TimeUtils.printSince(row.uptime);

                        JsonObject jo = (JsonObject) root.get("rests");
                        if (jo != null) {
                            JsonArray arr = (JsonArray) jo.get("rests");
                            if (arr != null) {
                                for (int i = 0; i < arr.size(); i++) {
                                    row = row.copy();
                                    jo = (JsonObject) arr.get(i);
                                    row.url = jo.getString("url");
                                    row.method = jo.getString("method").toUpperCase(Locale.ROOT);
                                    row.consumes = jo.getString("consumes");
                                    row.produces = jo.getString("produces");
                                    row.description = jo.getString("description");
                                    row.contractFirst = jo.getBooleanOrDefault("contractFirst", false);
                                    rows.add(row);
                                }
                            }
                        }
                    }
                });

         
        rows.sort(this::sortRow);

        if (!rows.isEmpty()) {
            printer().println(AsciiTable.getTable(AsciiTable.NO_BORDERS, rows, Arrays.asList(
                    new Column().header("PID").headerAlign(HorizontalAlign.CENTER).with(r -> r.pid),
                    new Column().header("NAME").dataAlign(HorizontalAlign.LEFT).maxWidth(30, OverflowBehaviour.ELLIPSIS_RIGHT)
                            .with(r -> r.name),
                    new Column().header("URL").dataAlign(HorizontalAlign.LEFT).with(r -> r.url),
                    new Column().header("METHOD").dataAlign(HorizontalAlign.LEFT).with(r -> r.method),
                    new Column().header("FIRST").visible(verbose).dataAlign(HorizontalAlign.LEFT).with(this::getKind),
                    new Column().header("DESCRIPTION").visible(verbose).maxWidth(40, OverflowBehaviour.NEWLINE)
                            .dataAlign(HorizontalAlign.LEFT).with(r -> r.description),
                    new Column().header("CONTENT-TYPE").dataAlign(HorizontalAlign.LEFT).with(this::getContent))));
        }

        return 0;
    }

    protected void doStart() throws Exception {
        super.doStart();

         
        if (listenerContainer == null) {
            createMessageListenerContainer();
        }
        getEndpoint().onListenerContainerStarting();

        if (getEndpoint().getConfiguration().isAsyncStartListener()) {
            getEndpoint().getAsyncStartStopExecutorService().submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        prepareAndStartListenerContainer();
                    } catch (Exception e) {
                        LOG.warn("Error starting listener container on destination: {}. This exception will be ignored.",
                                getDestinationName(), e);
                    }
                }

                @Override
                public String toString() {
                    return "AsyncStartListenerTask[" + getDestinationName() + "]";
                }
            });
        } else {
            prepareAndStartListenerContainer();
        }

         
        initialized = true;
    }

    public void writeTo(OutputStream outstream) throws IOException {
        NoCloseOutputStream ncos = new NoCloseOutputStream(outstream);

         
        if (!isMainBody()) {
            try (CanonicalOutputStream canonicalOutstream = new CanonicalOutputStream(ncos, StandardCharsets.US_ASCII.name())) {

                for (Header header : getAllHeaders()) {
                    canonicalOutstream.writeln(header.toString());
                }
                canonicalOutstream.writeln();  
                                              
                                              
            }
        }

         
        String transferEncoding = getContentTransferEncoding() == null ? null : getContentTransferEncoding().getValue();
        try (OutputStream transferEncodedStream = EntityUtils.encode(ncos, transferEncoding)) {

            transferEncodedStream.write(compressedData);
        } catch (Exception e) {
            throw new IOException("Failed to write to output stream", e);
        }
    }

    public Task schedule(BackOff backOff, ThrowingFunction<Task, Boolean, Exception> function) {
        final BackOffTimerTask task = new BackOffTimerTask(this, backOff, scheduler, function);

        long delay = task.next();
        if (delay != BackOff.NEVER) {
            tasks.add(task);
            scheduler.schedule(task, delay, TimeUnit.MILLISECONDS);
        } else {
            task.cancel();
        }

        return task;
    }

    private void add(Exchange exchange) throws Exception {
        final Message in = exchange.getMessage();

        String collectionName = getCollectionName(in);
        Collection collection = this.client.getCollection(collectionName, embeddingFunction);

        List<String> ids = in.getHeader(ChromaHeaders.IDS, List.class);
        List<Embedding> embeddings = getEmbeddings(in);
        List<Map<String, String>> metadatas = in.getHeader(ChromaHeaders.METADATAS, List.class);
        List<String> documents = in.getBody(List.class);

        collection.add(embeddings, metadatas, documents, ids);
        in.setHeader(ChromaHeaders.OPERATION_STATUS, "SUCCESS");
    }

    public <T> T convertTo(Class<T> type, Exchange exchange, Object value) {
        Object instance = injector.newInstance();
        if (instance == null) {
            throw new RuntimeCamelException("Could not instantiate an instance of: " + type.getCanonicalName());
        }
        Object answer = useExchange
                ? (T) ObjectHelper.invokeMethod(method, instance, value, exchange) : (T) ObjectHelper
                        .invokeMethod(method, instance, value);
        if (answer == null && allowNull) {
            answer = Void.class;
        }
        return (T) answer;
    }

        protected boolean setPropertyOnComponent(
                Component component,
                String name,
                Object value) {
            switch (name) {
            case "brokerURL": ((ActiveMQComponent) component).setBrokerURL((java.lang.String) value); return true;
            case "clientId": getOrCreateConfiguration((ActiveMQComponent) component).setClientId((java.lang.String) value); return true;
            case "connectionFactory": getOrCreateConfiguration((ActiveMQComponent) component).setConnectionFactory((jakarta.jms.ConnectionFactory) value); return true;
            case "disableReplyTo": getOrCreateConfiguration((ActiveMQComponent) component).setDisableReplyTo((boolean) value); return true;
            case "durableSubscriptionName": getOrCreateConfiguration((ActiveMQComponent) component).setDurableSubscriptionName((java.lang.String) value); return true;
            case "embedded": ((ActiveMQComponent) component).setEmbedded((boolean) value); return true;
            case "jmsMessageType": getOrCreateConfiguration((ActiveMQComponent) component).setJmsMessageType((org.apache.camel.component.jms.JmsMessageType) value); return true;
            case "replyTo": getOrCreateConfiguration((ActiveMQComponent) component).setReplyTo((java.lang.String) value); return true;
            case "testConnectionOnStartup": getOrCreateConfiguration((ActiveMQComponent) component).setTestConnectionOnStartup((boolean) value); return true;
            case "usePooledConnection": ((ActiveMQComponent) component).setUsePooledConnection((boolean) value); return true;
            case "useSingleConnection": ((ActiveMQComponent) component).setUseSingleConnection((boolean) value); return true;
            case "acknowledgementModeName": getOrCreateConfiguration((ActiveMQComponent) component).setAcknowledgementModeName((java.lang.String) value); return true;
            case "artemisConsumerPriority": getOrCreateConfiguration((ActiveMQComponent) component).setArtemisConsumerPriority((int) value); return true;
            case "asyncConsumer": getOrCreateConfiguration((ActiveMQComponent) component).setAsyncConsumer((boolean) value); return true;
            case "autoStartup": getOrCreateConfiguration((ActiveMQComponent) component).setAutoStartup((boolean) value); return true;
            case "cacheLevel": getOrCreateConfiguration((ActiveMQComponent) component).setCacheLevel((int) value); return true;
            case "cacheLevelName": getOrCreateConfiguration((ActiveMQComponent) component).setCacheLevelName((java.lang.String) value); return true;
            case "concurrentConsumers": getOrCreateConfiguration((ActiveMQComponent) component).setConcurrentConsumers((int) value); return true;
            case "maxConcurrentConsumers": getOrCreateConfiguration((ActiveMQComponent) component).setMaxConcurrentConsumers((int) value); return true;
            case "replyToDeliveryPersistent": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToDeliveryPersistent((boolean) value); return true;
            case "selector": getOrCreateConfiguration((ActiveMQComponent) component).setSelector((java.lang.String) value); return true;
            case "subscriptionDurable": getOrCreateConfiguration((ActiveMQComponent) component).setSubscriptionDurable((boolean) value); return true;
            case "subscriptionName": getOrCreateConfiguration((ActiveMQComponent) component).setSubscriptionName((java.lang.String) value); return true;
            case "subscriptionShared": getOrCreateConfiguration((ActiveMQComponent) component).setSubscriptionShared((boolean) value); return true;
            case "acceptMessagesWhileStopping": getOrCreateConfiguration((ActiveMQComponent) component).setAcceptMessagesWhileStopping((boolean) value); return true;
            case "allowReplyManagerQuickStop": getOrCreateConfiguration((ActiveMQComponent) component).setAllowReplyManagerQuickStop((boolean) value); return true;
            case "consumerType": getOrCreateConfiguration((ActiveMQComponent) component).setConsumerType((org.apache.camel.component.jms.ConsumerType) value); return true;
            case "defaultTaskExecutorType": getOrCreateConfiguration((ActiveMQComponent) component).setDefaultTaskExecutorType((org.apache.camel.component.jms.DefaultTaskExecutorType) value); return true;
            case "eagerLoadingOfProperties": getOrCreateConfiguration((ActiveMQComponent) component).setEagerLoadingOfProperties((boolean) value); return true;
            case "eagerPoisonBody": getOrCreateConfiguration((ActiveMQComponent) component).setEagerPoisonBody((java.lang.String) value); return true;
            case "exposeListenerSession": getOrCreateConfiguration((ActiveMQComponent) component).setExposeListenerSession((boolean) value); return true;
            case "replyToConsumerType": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToConsumerType((org.apache.camel.component.jms.ConsumerType) value); return true;
            case "replyToSameDestinationAllowed": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToSameDestinationAllowed((boolean) value); return true;
            case "taskExecutor": getOrCreateConfiguration((ActiveMQComponent) component).setTaskExecutor((org.springframework.core.task.TaskExecutor) value); return true;
            case "deliveryDelay": getOrCreateConfiguration((ActiveMQComponent) component).setDeliveryDelay((long) value); return true;
            case "deliveryMode": getOrCreateConfiguration((ActiveMQComponent) component).setDeliveryMode((java.lang.Integer) value); return true;
            case "deliveryPersistent": getOrCreateConfiguration((ActiveMQComponent) component).setDeliveryPersistent((boolean) value); return true;
            case "explicitQosEnabled": getOrCreateConfiguration((ActiveMQComponent) component).setExplicitQosEnabled((java.lang.Boolean) value); return true;
            case "formatDateHeadersToIso8601": getOrCreateConfiguration((ActiveMQComponent) component).setFormatDateHeadersToIso8601((boolean) value); return true;
            case "lazyStartProducer": ((ActiveMQComponent) component).setLazyStartProducer((boolean) value); return true;
            case "preserveMessageQos": getOrCreateConfiguration((ActiveMQComponent) component).setPreserveMessageQos((boolean) value); return true;
            case "priority": getOrCreateConfiguration((ActiveMQComponent) component).setPriority((int) value); return true;
            case "replyToConcurrentConsumers": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToConcurrentConsumers((int) value); return true;
            case "replyToMaxConcurrentConsumers": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToMaxConcurrentConsumers((int) value); return true;
            case "replyToOnTimeoutMaxConcurrentConsumers": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToOnTimeoutMaxConcurrentConsumers((int) value); return true;
            case "replyToOverride": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToOverride((java.lang.String) value); return true;
            case "replyToType": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToType((org.apache.camel.component.jms.ReplyToType) value); return true;
            case "requestTimeout": getOrCreateConfiguration((ActiveMQComponent) component).setRequestTimeout((long) value); return true;
            case "timeToLive": getOrCreateConfiguration((ActiveMQComponent) component).setTimeToLive((long) value); return true;
            case "allowAdditionalHeaders": getOrCreateConfiguration((ActiveMQComponent) component).setAllowAdditionalHeaders((java.lang.String) value); return true;
            case "allowNullBody": getOrCreateConfiguration((ActiveMQComponent) component).setAllowNullBody((boolean) value); return true;
            case "alwaysCopyMessage": getOrCreateConfiguration((ActiveMQComponent) component).setAlwaysCopyMessage((boolean) value); return true;
            case "correlationProperty": getOrCreateConfiguration((ActiveMQComponent) component).setCorrelationProperty((java.lang.String) value); return true;
            case "disableTimeToLive": getOrCreateConfiguration((ActiveMQComponent) component).setDisableTimeToLive((boolean) value); return true;
            case "forceSendOriginalMessage": getOrCreateConfiguration((ActiveMQComponent) component).setForceSendOriginalMessage((boolean) value); return true;
            case "includeSentJMSMessageID": getOrCreateConfiguration((ActiveMQComponent) component).setIncludeSentJMSMessageID((boolean) value); return true;
            case "replyCorrelationProperty": getOrCreateConfiguration((ActiveMQComponent) component).setReplyCorrelationProperty((java.lang.String) value); return true;
            case "replyToCacheLevelName": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToCacheLevelName((java.lang.String) value); return true;
            case "replyToDestinationSelectorName": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToDestinationSelectorName((java.lang.String) value); return true;
            case "streamMessageTypeEnabled": getOrCreateConfiguration((ActiveMQComponent) component).setStreamMessageTypeEnabled((boolean) value); return true;
            case "allowAutoWiredConnectionFactory": ((ActiveMQComponent) component).setAllowAutoWiredConnectionFactory((boolean) value); return true;
            case "allowAutoWiredDestinationResolver": ((ActiveMQComponent) component).setAllowAutoWiredDestinationResolver((boolean) value); return true;
            case "allowSerializedHeaders": getOrCreateConfiguration((ActiveMQComponent) component).setAllowSerializedHeaders((boolean) value); return true;
            case "artemisStreamingEnabled": getOrCreateConfiguration((ActiveMQComponent) component).setArtemisStreamingEnabled((boolean) value); return true;
            case "asyncStartListener": getOrCreateConfiguration((ActiveMQComponent) component).setAsyncStartListener((boolean) value); return true;
            case "asyncStopListener": getOrCreateConfiguration((ActiveMQComponent) component).setAsyncStopListener((boolean) value); return true;
            case "autowiredEnabled": ((ActiveMQComponent) component).setAutowiredEnabled((boolean) value); return true;
            case "browseLimit": getOrCreateConfiguration((ActiveMQComponent) component).setBrowseLimit((int) value); return true;
            case "configuration": ((ActiveMQComponent) component).setConfiguration((org.apache.camel.component.jms.JmsConfiguration) value); return true;
            case "destinationResolver": getOrCreateConfiguration((ActiveMQComponent) component).setDestinationResolver((org.springframework.jms.support.destination.DestinationResolver) value); return true;
            case "errorHandler": getOrCreateConfiguration((ActiveMQComponent) component).setErrorHandler((org.springframework.util.ErrorHandler) value); return true;
            case "exceptionListener": getOrCreateConfiguration((ActiveMQComponent) component).setExceptionListener((jakarta.jms.ExceptionListener) value); return true;
            case "idleConsumerLimit": getOrCreateConfiguration((ActiveMQComponent) component).setIdleConsumerLimit((int) value); return true;
            case "idleReceivesPerTaskLimit": getOrCreateConfiguration((ActiveMQComponent) component).setIdleReceivesPerTaskLimit((int) value); return true;
            case "idleTaskExecutionLimit": getOrCreateConfiguration((ActiveMQComponent) component).setIdleTaskExecutionLimit((int) value); return true;
            case "includeAllJMSXProperties": getOrCreateConfiguration((ActiveMQComponent) component).setIncludeAllJMSXProperties((boolean) value); return true;
            case "includeCorrelationIDAsBytes": ((ActiveMQComponent) component).setIncludeCorrelationIDAsBytes((boolean) value); return true;
            case "jmsKeyFormatStrategy": getOrCreateConfiguration((ActiveMQComponent) component).setJmsKeyFormatStrategy((org.apache.camel.component.jms.JmsKeyFormatStrategy) value); return true;
            case "mapJmsMessage": getOrCreateConfiguration((ActiveMQComponent) component).setMapJmsMessage((boolean) value); return true;
            case "maxMessagesPerTask": getOrCreateConfiguration((ActiveMQComponent) component).setMaxMessagesPerTask((int) value); return true;
            case "messageConverter": getOrCreateConfiguration((ActiveMQComponent) component).setMessageConverter((org.springframework.jms.support.converter.MessageConverter) value); return true;
            case "messageCreatedStrategy": getOrCreateConfiguration((ActiveMQComponent) component).setMessageCreatedStrategy((org.apache.camel.component.jms.MessageCreatedStrategy) value); return true;
            case "messageIdEnabled": getOrCreateConfiguration((ActiveMQComponent) component).setMessageIdEnabled((boolean) value); return true;
            case "messageListenerContainerFactory": getOrCreateConfiguration((ActiveMQComponent) component).setMessageListenerContainerFactory((org.apache.camel.component.jms.MessageListenerContainerFactory) value); return true;
            case "messageTimestampEnabled": getOrCreateConfiguration((ActiveMQComponent) component).setMessageTimestampEnabled((boolean) value); return true;
            case "pubSubNoLocal": getOrCreateConfiguration((ActiveMQComponent) component).setPubSubNoLocal((boolean) value); return true;
            case "queueBrowseStrategy": ((ActiveMQComponent) component).setQueueBrowseStrategy((org.apache.camel.component.jms.QueueBrowseStrategy) value); return true;
            case "receiveTimeout": getOrCreateConfiguration((ActiveMQComponent) component).setReceiveTimeout((long) value); return true;
            case "recoveryInterval": getOrCreateConfiguration((ActiveMQComponent) component).setRecoveryInterval((long) value); return true;
            case "requestTimeoutCheckerInterval": getOrCreateConfiguration((ActiveMQComponent) component).setRequestTimeoutCheckerInterval((long) value); return true;
            case "serviceLocationEnabled": ((ActiveMQComponent) component).setServiceLocationEnabled((boolean) value); return true;
            case "synchronous": getOrCreateConfiguration((ActiveMQComponent) component).setSynchronous((boolean) value); return true;
            case "temporaryQueueResolver": getOrCreateConfiguration((ActiveMQComponent) component).setTemporaryQueueResolver((org.apache.camel.component.jms.TemporaryQueueResolver) value); return true;
            case "transferException": getOrCreateConfiguration((ActiveMQComponent) component).setTransferException((boolean) value); return true;
            case "transferExchange": getOrCreateConfiguration((ActiveMQComponent) component).setTransferExchange((boolean) value); return true;
            case "trustAllPackages": ((ActiveMQComponent) component).setTrustAllPackages((boolean) value); return true;
            case "useMessageIDAsCorrelationID": getOrCreateConfiguration((ActiveMQComponent) component).setUseMessageIDAsCorrelationID((boolean) value); return true;
            case "waitForProvisionCorrelationToBeUpdatedCounter": getOrCreateConfiguration((ActiveMQComponent) component).setWaitForProvisionCorrelationToBeUpdatedCounter((int) value); return true;
            case "waitForProvisionCorrelationToBeUpdatedThreadSleepingTime": getOrCreateConfiguration((ActiveMQComponent) component).setWaitForProvisionCorrelationToBeUpdatedThreadSleepingTime((long) value); return true;
            case "waitForTemporaryReplyToToBeUpdatedCounter": getOrCreateConfiguration((ActiveMQComponent) component).setWaitForTemporaryReplyToToBeUpdatedCounter((int) value); return true;
            case "waitForTemporaryReplyToToBeUpdatedThreadSleepingTime": getOrCreateConfiguration((ActiveMQComponent) component).setWaitForTemporaryReplyToToBeUpdatedThreadSleepingTime((long) value); return true;
            case "headerFilterStrategy": ((ActiveMQComponent) component).setHeaderFilterStrategy((org.apache.camel.spi.HeaderFilterStrategy) value); return true;
            case "errorHandlerLoggingLevel": getOrCreateConfiguration((ActiveMQComponent) component).setErrorHandlerLoggingLevel((org.apache.camel.LoggingLevel) value); return true;
            case "errorHandlerLogStackTrace": getOrCreateConfiguration((ActiveMQComponent) component).setErrorHandlerLogStackTrace((boolean) value); return true;
            case "password": getOrCreateConfiguration((ActiveMQComponent) component).setPassword((java.lang.String) value); return true;
            case "username": getOrCreateConfiguration((ActiveMQComponent) component).setUsername((java.lang.String) value); return true;
            case "transacted": getOrCreateConfiguration((ActiveMQComponent) component).setTransacted((boolean) value); return true;
            case "transactedInOut": getOrCreateConfiguration((ActiveMQComponent) component).setTransactedInOut((boolean) value); return true;
            case "lazyCreateTransactionManager": getOrCreateConfiguration((ActiveMQComponent) component).setLazyCreateTransactionManager((boolean) value); return true;
            case "transactionManager": getOrCreateConfiguration((ActiveMQComponent) component).setTransactionManager((org.springframework.transaction.PlatformTransactionManager) value); return true;
            case "transactionName": getOrCreateConfiguration((ActiveMQComponent) component).setTransactionName((java.lang.String) value); return true;
            case "transactionTimeout": getOrCreateConfiguration((ActiveMQComponent) component).setTransactionTimeout((int) value); return true;
            default: return false;
            }
        }

        protected void onExceptionOccurred() {
            if (onExceptionProcessor == null) {
                return;
            }

             
            try {
                if (LOG.isTraceEnabled()) {
                    LOG.trace("OnExceptionOccurred processor {} is processing Exchange: {} due exception occurred",
                            onExceptionProcessor, exchange);
                }
                onExceptionProcessor.process(exchange);
            } catch (Exception e) {
                 
                LOG.warn("Error during processing OnExceptionOccurred. This exception is ignored.", e);
            }
            LOG.trace("OnExceptionOccurred processor done");
        }

    private void processGetBatch(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {
        String jobId;
        BatchInfo batchBody = exchange.getIn().getBody(BatchInfo.class);
        String batchId;
        if (batchBody != null) {
            jobId = batchBody.getJobId();
            batchId = batchBody.getId();
        } else {
            jobId = getParameter(JOB_ID, exchange, IGNORE_BODY, NOT_OPTIONAL);
            batchId = getParameter(BATCH_ID, exchange, USE_BODY, NOT_OPTIONAL);
        }
        bulkClient.getBatch(jobId, batchId, determineHeaders(exchange), new BulkApiClient.BatchInfoResponseCallback() {
            @Override
            public void onResponse(BatchInfo batchInfo, Map<String, String> headers, SalesforceException ex) {
                processResponse(exchange, batchInfo, headers, ex, callback);
            }
        });
    }

        public void run() {
            FilterWatchListDeletable<Deployment, DeploymentList, RollableScalableResource<Deployment>> w;

             
            String namespace = getEndpoint().getKubernetesConfiguration().getNamespace();
            String labelKey = getEndpoint().getKubernetesConfiguration().getLabelKey();
            String labelValue = getEndpoint().getKubernetesConfiguration().getLabelValue();
            String resourceName = getEndpoint().getKubernetesConfiguration().getResourceName();

            if (ObjectHelper.isEmpty(namespace)) {
                w = getEndpoint().getKubernetesClient().apps().deployments().inAnyNamespace();

                if (ObjectHelper.isNotEmpty(labelKey) && ObjectHelper.isNotEmpty(labelValue)) {
                    w = w.withLabel(labelKey, labelValue);
                }
            } else {
                final NonNamespaceOperation<Deployment, DeploymentList, RollableScalableResource<Deployment>> client
                        = getEndpoint().getKubernetesClient().apps().deployments().inNamespace(namespace);
                w = client;
                if (ObjectHelper.isNotEmpty(labelKey) && ObjectHelper.isNotEmpty(labelValue)) {
                    w = client.withLabel(labelKey, labelValue);
                } else if (ObjectHelper.isNotEmpty(resourceName)) {
                    w = (FilterWatchListDeletable<Deployment, DeploymentList, RollableScalableResource<Deployment>>) client
                            .withName(resourceName);
                }
            }

            watch = w.watch(new Watcher<>() {

                @Override
                public void eventReceived(Action action, Deployment resource) {
                    Exchange exchange = createExchange(false);
                    exchange.getIn().setBody(resource);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_ACTION, action);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_TIMESTAMP, System.currentTimeMillis());
                    try {
                        processor.process(exchange);
                    } catch (Exception e) {
                        getExceptionHandler().handleException("Error during processing", exchange, e);
                    } finally {
                        releaseExchange(exchange, false);
                    }
                }

                @Override
                public void onClose(WatcherException cause) {
                    if (cause != null) {
                        LOG.error(cause.getMessage(), cause);
                    }

                }
            });
        }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.mongodb.ReadPreference.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.mongodb.gridfs.GridFsConverter.toReadPreference((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, com.mongodb.WriteConcern.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.mongodb.gridfs.GridFsConverter.toWriteConcern((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    public void initialize(Server server, Bus bus) {
        server.getEndpoint().put("org.apache.cxf.binding.soap.addNamespaceContext", "true");
        server.getEndpoint().getBinding().getInInterceptors().add(new ConfigureDocLitWrapperInterceptor(true));
        if (server.getEndpoint().getBinding() instanceof SoapBinding) {
            server.getEndpoint().getBinding().getOutInterceptors().add(new SetSoapVersionInterceptor());
        }
         
         
        removeInterceptor(server.getEndpoint().getInInterceptors(),
                HolderInInterceptor.class);
        removeInterceptor(server.getEndpoint().getOutInterceptors(),
                HolderOutInterceptor.class);
        removeInterceptor(server.getEndpoint().getBinding().getInInterceptors(),
                SoapHeaderInterceptor.class);
        resetPartTypes(server.getEndpoint().getBinding());

        LOG.info("Initialized CXF Server: {} in Payload mode with allow streaming: {}", server, allowStreaming);
    }

    public static Predicate endsWith(final Expression left, final Expression right) {
        return new BinaryPredicateSupport(left, right) {

            protected boolean matches(Exchange exchange, Object leftValue, Object rightValue) {
                return LanguageHelper.endsWith(exchange, leftValue, rightValue);
            }

            protected String getOperationText() {
                return "endsWith";
            }
        };
    }

    public RoutePolicy createRoutePolicy(CamelContext camelContext, String routeId, NamedNode routeDefinition) {
        MicrometerRoutePolicy answer = new MicrometerRoutePolicy(this);
        answer.setMeterRegistry(getMeterRegistry());
        answer.setPrettyPrint(isPrettyPrint());
        answer.setSkipCamelInfo(isSkipCamelInfo());
        answer.setDurationUnit(getDurationUnit());
        answer.setNamingStrategy(getNamingStrategy());
        answer.setConfiguration(getPolicyConfiguration());
        return answer;
    }

    public void onInvalidateAll(Message message) {
        Set<?> keys = message.getHeader(CaffeineConstants.KEYS, Set.class);
         
        if (keys == null) {
            cache.invalidateAll();
        } else {
            cache.invalidateAll(keys);
        }

        setResult(message, true, null, null);
    }

    public boolean exists() {
        if (!init) {
            try {
                URL u = URI.create(getLocation()).toURL();
                try (InputStream is = u.openStream()) {
                    cache = camelContext.getTypeConverter().tryConvertTo(byte[].class, is);
                }
            } catch (Exception e) {
                 
            }
            init = true;
        }
        return cache != null;
    }

    public Producer createProducer() throws Exception {
        switch (getSubsystem()) {
            case KeystoneConstants.REGIONS:
                return new RegionProducer(this, createClient());
            case KeystoneConstants.DOMAINS:
                return new DomainProducer(this, createClient());
            case KeystoneConstants.PROJECTS:
                return new ProjectProducer(this, createClient());
            case KeystoneConstants.USERS:
                return new UserProducer(this, createClient());
            case KeystoneConstants.GROUPS:
                return new GroupProducer(this, createClient());
            default:
                throw new IllegalArgumentException("Can't create producer with subsystem " + subsystem);
        }
    }

    protected void doCall(Map<String, Object> options, Function<ManagedRouteMBean, Object> task) {
        String path = (String) options.get(Exchange.HTTP_PATH);
        String subPath = path != null ? StringHelper.after(path, "/") : null;
        String filter = (String) options.get(FILTER);
        String limit = (String) options.get(LIMIT);
        final int max = limit == null ? Integer.MAX_VALUE : Integer.parseInt(limit);

        ManagedCamelContext mcc = getCamelContext().getCamelContextExtension().getContextPlugin(ManagedCamelContext.class);
        if (mcc != null) {
            List<Route> routes = getCamelContext().getRoutes();
            routes.sort((o1, o2) -> o1.getRouteId().compareToIgnoreCase(o2.getRouteId()));
            routes.stream()
                    .map(route -> mcc.getManagedRoute(route.getRouteId()))
                    .filter(Objects::nonNull)
                    .filter(r -> accept(r, filter))
                    .filter(r -> accept(r, subPath))
                    .sorted(RouteStructureDevConsole::sort)
                    .limit(max)
                    .forEach(task::apply);
        }
    }

    private String getUri(Row r) {
        String u = r.uri;
        if (shortUri) {
            int pos = u.indexOf('?');
            if (pos > 0) {
                u = u.substring(0, pos);
            }
        }
        return u;
    }

    public RestDefinition id(String id) {
        if (getVerbs().isEmpty()) {
            super.id(id);
        } else {
             
            VerbDefinition verb = getVerbs().get(getVerbs().size() - 1);
            verb.id(id);
        }

        return this;
    }

    private static boolean isAnalyticsOperation(OperationName operationName) {
        switch (operationName) {
            case GET_RECENT_REPORTS:
            case GET_REPORT_DESCRIPTION:
            case EXECUTE_SYNCREPORT:
            case EXECUTE_ASYNCREPORT:
            case GET_REPORT_INSTANCES:
            case GET_REPORT_RESULTS:
                return true;
            default:
                return false;
        }
    }

    public static DocumentBuilderFactory createDocumentBuilderFactory() {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        factory.setNamespaceAware(true);
        factory.setIgnoringElementContentWhitespace(true);
        factory.setIgnoringComments(true);
        try {
             
            factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, Boolean.TRUE);
        } catch (ParserConfigurationException e) {
        }
        try {
             
            factory.setFeature("http://xml.org/sax/features/external-general-entities", false);
        } catch (ParserConfigurationException e) {
        }
        try {
             
            factory.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
        } catch (ParserConfigurationException e) {
        }
         
        try {
            Class<?> smClass = ObjectHelper.loadClass("org.apache.xerces.util.SecurityManager");
            if (smClass != null) {
                Object sm = smClass.getDeclaredConstructor().newInstance();
                 
                factory.setAttribute("http://apache.org/xml/properties/security-manager", sm);
            }
        } catch (Exception e) {
        }
        return factory;
    }

    public String resolveStaticUri(Exchange exchange, DynamicAwareEntry entry) throws Exception {
        String topic = parseTopicName(entry.getUri());
        if (topic != null) {
            String originalTopic = parseTopicName(entry.getOriginalUri());
            if (!topic.equals(originalTopic)) {
                 
                String answer = entry.getUri();
                answer = StringHelper.replaceFirst(answer, topic, originalTopic);
                return answer;
            }
        }
        return null;
    }

    private Exchange createExchangeFromFile(final String fileName, final DataLakeFileSystemClient dataLakeFileSystemClient)
            throws IOException {
        final DataLakeFileClientWrapper clientWrapper
                = new DataLakeFileClientWrapper(dataLakeFileSystemClient.getFileClient(fileName));
        final DataLakeFileOperations operations = new DataLakeFileOperations(getEndpoint().getConfiguration(), clientWrapper);
        final Exchange exchange = createExchange(true);

        DataLakeOperationResponse response;

        if (ObjectHelper.isNotEmpty(getEndpoint().getConfiguration().getFileDir())) {
            response = operations.downloadToFile(exchange);
        } else {
            response = operations.getFile(exchange);
        }

        getEndpoint().setResponseOnExchange(response, exchange);

        exchange.getIn().setHeader(DataLakeConstants.FILE_NAME, fileName);
        return exchange;
    }

    private Object handleInvoices(Exchange exchange, String method) throws Exception {
        switch (method) {
            case StripeConstants.METHOD_CREATE:
                return Invoice.create(getParametersFromBody(exchange));
            case StripeConstants.METHOD_RETRIEVE:
                String id = exchange.getIn().getHeader(StripeConstants.OBJECT_ID, String.class);
                return Invoice.retrieve(id);
            case StripeConstants.METHOD_UPDATE:
                String invoiceId = exchange.getIn().getHeader(StripeConstants.OBJECT_ID, String.class);
                Invoice invoice = Invoice.retrieve(invoiceId);
                return invoice.update(getParametersFromBody(exchange));
            case StripeConstants.METHOD_LIST:
                return Invoice.list(getParametersFromBody(exchange));
            default:
                throw new IllegalArgumentException("Unsupported method for invoices: " + method);
        }
    }

    protected int poll() throws Exception {
        Exchange exchange = receive(getEndpoint().getReadTimeout());
        if (exchange != null) {
            getProcessor().process(exchange);
            return 1;
        } else {
            return 0;
        }
    }

    public boolean acquireExclusiveReadLock(GenericFileOperations<File> operations, GenericFile<File> file, Exchange exchange)
            throws Exception {
         
         
        File path = file.getFile();
        if (!path.exists()) {
            return false;
        }

         
        String key = asKey(exchange, file);
        boolean answer = false;
        try {
            answer = idempotentRepository.add(exchange, key);
        } catch (Exception e) {
            if (LOG.isTraceEnabled()) {
                LOG.trace("Cannot acquire read lock due to {}. Will skip the file: {}", e.getMessage(), file, e);
            }
        }
        if (!answer) {
             
            CamelLogger.log(LOG, readLockLoggingLevel, "Cannot acquire read lock. Will skip the file: " + file);
        }

        if (answer) {
             
            answer = changed.acquireExclusiveReadLock(operations, file, exchange);
            if (!answer) {
                 
                idempotentRepository.remove(exchange, key);
            }
        }
        return answer;
    }

    public Drive makeClient(
            CamelContext camelContext, String serviceAccountKey, Collection<String> scopes, String applicationName,
            String delegate) {
        if (serviceAccountKey == null) {
            throw new IllegalArgumentException("serviceAccountKey is required to create Drive client.");
        }
        try {
            Credential credential = authorizeServiceAccount(camelContext, serviceAccountKey, delegate, scopes);
            return new Drive.Builder(transport, jsonFactory, credential).setApplicationName(applicationName).build();
        } catch (Exception e) {
            throw new RuntimeCamelException("Could not create Drive client.", e);
        }
    }

    private int readReceiveFiles(Map<Long, Pid> pids) throws Exception {
        int lines = 0;

        for (Pid pid : pids.values()) {
            if (pid.reader == null) {
                Path file = getReceiveFile(pid.pid);
                if (Files.exists(file)) {
                    pid.reader = new LineNumberReader(Files.newBufferedReader(file));
                    if (tail == 0) {
                         
                        long size = Files.size(file);
                        pid.reader.skip(size);
                    }
                }
            }
            if (pid.reader != null) {
                String line;
                do {
                    try {
                        line = pid.reader.readLine();
                        if (line != null) {
                            lines++;
                             
                            if (pid.fifo == null || pid.fifo instanceof ArrayBlockingQueue) {
                                pid.fifo = new ArrayDeque<>();
                            }
                            pid.fifo.offer(line);
                        }
                    } catch (IOException e) {
                         
                        line = null;
                    }
                } while (line != null);
            }
        }

        return lines;
    }

    public void put(String chatId, CamelToolSpecification specification) {
        if (tools.get(chatId) != null) {
            tools.get(chatId).add(specification);
        } else {
            Set<CamelToolSpecification> camelToolSpecifications = new LinkedHashSet<>();
            camelToolSpecifications.add(specification);
            tools.put(chatId, camelToolSpecifications);
        }
    }

    protected boolean matchSecret(String name) {
        Set<String> set = new HashSet<>();
        if (secrets != null) {
            Collections.addAll(set, secrets.split(","));
        }
        if (propertiesFunction != null) {
            set.addAll(propertiesFunction.getSecrets());
        }

        for (String part : set) {
            boolean result = name.contains(part) || PatternHelper.matchPattern(name, part);
            LOG.trace("Matching secret id: {}={} -> {}", name, part, result);
            if (result) {
                return true;
            }
        }

        return false;
    }

    protected void processExchange(Exchange exchange, RoutingContext routingContext) {
        routingContext.vertx().executeBlocking(() -> {
            createUoW(exchange);
            getProcessor().process(exchange);
            return null;
        }, false)
                .onComplete(result -> {
                    try {
                        if (result.failed()) {
                            Throwable cause = result.cause();
                            getExceptionHandler().handleException(cause);
                            routingContext.fail(cause);
                        }
                    } finally {
                        doneUoW(exchange);
                        releaseExchange(exchange, false);
                    }
                });
    }

    private void rebootInstances(Ec2Client ec2Client, Exchange exchange) throws InvalidPayloadException {
        Collection<String> instanceIds;
        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RebootInstancesRequest) {
                try {
                    LOG.trace("Rebooting instances with Ids [{}] ", ((RebootInstancesRequest) payload).instanceIds());
                    ec2Client.rebootInstances((RebootInstancesRequest) payload);
                } catch (AwsServiceException ase) {
                    LOG.trace("Reboot Instances command returned the error code {}", ase.awsErrorDetails().errorCode());
                    throw ase;
                }
            }
        } else {
            RebootInstancesRequest.Builder builder = RebootInstancesRequest.builder();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(AWS2EC2Constants.INSTANCES_IDS))) {
                instanceIds = exchange.getIn().getHeader(AWS2EC2Constants.INSTANCES_IDS, Collection.class);
                builder.instanceIds(instanceIds);
            } else {
                throw new IllegalArgumentException(MISSING_INSTANCES_MESSAGE);
            }
            try {
                if (LOG.isTraceEnabled()) {
                    LOG.trace("Rebooting instances with Ids [{}] ", Arrays.toString(instanceIds.toArray()));
                }

                ec2Client.rebootInstances(builder.build());
            } catch (AwsServiceException ase) {
                LOG.trace("Reboot Instances command returned the error code {}", ase.awsErrorDetails().errorCode());
                throw ase;
            }
        }
    }

    protected void doStart() throws Exception {
        super.doStart();

        if (folder == null) {
             
            return;
        }
        if (!scheduler) {
             
            return;
        }

        File dir = new File(folder);
        if (dir.exists() && dir.isDirectory()) {
            String msg = startupMessage(dir);
            if (msg != null) {
                LOG.info(msg);
            }

            WatchEvent.Modifier modifier = null;

             
            String os = ObjectHelper.getSystemProperty("os.name", "");
            if (os.toLowerCase(Locale.US).startsWith("mac")) {
                 
                Class<WatchEvent.Modifier> clazz = getCamelContext().getClassResolver()
                        .resolveClass("com.sun.nio.file.SensitivityWatchEventModifier", WatchEvent.Modifier.class);
                if (clazz != null) {
                    WatchEvent.Modifier[] modifiers = clazz.getEnumConstants();
                    for (WatchEvent.Modifier mod : modifiers) {
                        if ("HIGH".equals(mod.name())) {
                            modifier = mod;
                            break;
                        }
                    }
                }
                if (modifier != null) {
                    LOG.debug(
                            "On Mac OS X the JDK WatchService is slow by default so enabling SensitivityWatchEventModifier.HIGH as workaround");
                } else {
                    LOG.warn(
                            "On Mac OS X the JDK WatchService is slow and it may take up till 10 seconds to notice file changes");
                }
            }

            try {
                Path path = dir.toPath();
                watcher = path.getFileSystem().newWatchService();
                 
                if (isRecursive) {
                    this.folderKeys = new HashMap<>();
                    registerRecursive(watcher, path, modifier);
                } else {
                    registerPathToWatcher(modifier, path, watcher);
                }

                task = new WatchFileChangesTask(watcher, path);

                executorService = getCamelContext().getExecutorServiceManager().newSingleThreadExecutor(this,
                        "FileWatcherReloadStrategy");
                executorService.submit(task);
            } catch (IOException e) {
                throw RuntimeCamelException.wrapRuntimeCamelException(e);
            }
        }
    }

    private boolean updateOptionsIn(final File file, final String kind, final String changed) throws MojoExecutionException {
        if (!file.exists()) {
            return false;
        }

        final String updated = changed.trim();
        try {
            String text = PackageHelper.loadText(file);

            String existing = Strings.between(text, "// " + kind + " options: START", "// " + kind + " options: END");
            if (existing != null) {
                 
                existing = existing.trim();
                if (existing.equals(updated)) {
                    return false;
                }

                String before = Strings.before(text, "// " + kind + " options: START");
                String after = Strings.after(text, "// " + kind + " options: END");
                text = before + "// " + kind + " options: START\n" + updated + "\n// " + kind + " options: END" + after;
                PackageHelper.writeText(file, text);
                return true;
            }

            getLog().warn("Cannot find markers in file " + file);
            getLog().warn("Add the following markers");
            getLog().warn("\t// " + kind + " options: START");
            getLog().warn("\t// " + kind + " options: END");
            if (isFailFast()) {
                throw new MojoExecutionException("Failed build due failFast=true");
            }
            return false;
        } catch (IOException e) {
            throw new MojoExecutionException("Error reading file " + file + " Reason: " + e, e);
        }
    }

    public static void registerDownloadReifiers(KameletMain main) {

        ProcessorReifier.registerReifier(SagaDefinition.class,
                (route, processorDefinition) -> {
                    if (processorDefinition instanceof SagaDefinition) {
                        DependencyDownloader downloader = route.getCamelContext().hasService(DependencyDownloader.class);
                        if (downloader != null) {
                            downloader.downloadDependency("org.apache.camel", "camel-saga",
                                    route.getCamelContext().getVersion());
                            downloader.downloadDependency("org.apache.camel", "camel-lra",
                                    route.getCamelContext().getVersion());
                        }
                    }
                    main.bind("inMemorySagaService", new InMemorySagaService());
                    return ProcessReifier.coreReifier(route, processorDefinition);
                });
    }

    private void doGetState(Exchange exchange, AsyncCallback callback) {
        endpoint.getPubnub()
                .getPresenceState()
                .channels(List.of(getChannel(exchange)))
                .uuid(getUUID(exchange))
                .async((Result<PNGetStateResult> result) -> {
                    LOG.debug("Got state [{}]", result);
                    if (result.isFailure()) {
                        PubNubException ex = result.exceptionOrNull();
                        if (ex != null) {
                            exchange.setException(ex);
                        }
                        callback.done(false);
                    } else {
                        PNGetStateResult r = result.getOrNull();
                        processMessage(exchange, callback, r);
                    }
                });
    }

    protected void stopVertx() {
        if (this.vertx == null || !this.localVertx) {
            return;
        }

        try {
            CompletableFuture.runAsync(
                    () -> {
                        CountDownLatch latch = new CountDownLatch(1);

                        vertx.close(result -> {
                            try {
                                if (result.failed()) {
                                    LOGGER.warn("Failed to close Vert.x reason: {}",
                                            result.cause().getMessage());

                                    throw new RuntimeException(result.cause());
                                }

                                LOGGER.debug("Vert.x stopped");
                            } finally {
                                latch.countDown();
                            }
                        });

                        try {
                            latch.await();
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                            throw new RuntimeException(e);
                        }
                    },
                    executor).toCompletableFuture().join();
        } finally {
            this.vertx = null;
            this.localVertx = false;
        }
    }

    public void getQueryResult(
            String jobId, String batchId, String resultId, Map<String, List<String>> headers,
            final StreamResponseCallback callback) {
        final Request get = getRequest(HttpMethod.GET, batchResultUrl(jobId, batchId, resultId), headers);

         
        doHttpRequest(get, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                callback.onResponse(response, headers, ex);
            }
        });
    }

    public static Expression mandatoryBodyExpression(final String name) {
        return new ExpressionAdapter() {
            private ClassResolver classResolver;
            private Expression exp;

            @Override
            public Object evaluate(Exchange exchange) {
                String text = exp.evaluate(exchange, String.class);
                Class<?> type;
                try {
                    type = classResolver.resolveMandatoryClass(text);
                } catch (ClassNotFoundException e) {
                    throw CamelExecutionException.wrapCamelExecutionException(exchange, e);
                }
                try {
                    return exchange.getIn().getMandatoryBody(type);
                } catch (InvalidPayloadException e) {
                    throw CamelExecutionException.wrapCamelExecutionException(exchange, e);
                }
            }

            @Override
            public void init(CamelContext context) {
                classResolver = context.getClassResolver();
                exp = ExpressionBuilder.simpleExpression(name);
                exp.init(context);
            }

            @Override
            public String toString() {
                return "mandatoryBodyAs[" + name + "]";
            }
        };
    }

    public static void skipToBoundary(AS2SessionInputBuffer inbuffer, InputStream is, String boundary)
            throws HttpException {

        boolean foundEndBoundary;
        try {
            foundEndBoundary = false;
            CharArrayBuffer lineBuffer = new CharArrayBuffer(1024);
            while (inbuffer.readLine(lineBuffer, is) != -1) {
                final ParserCursor cursor = new ParserCursor(0, lineBuffer.length());
                if (isBoundaryDelimiter(lineBuffer, cursor, boundary)) {
                    foundEndBoundary = true;
                    break;
                }
                lineBuffer.clear();
            }
        } catch (Exception e) {
            throw new HttpException("Failed to read start boundary for body part", e);
        }

        if (!foundEndBoundary && boundary != null) {
            throw new HttpException("Failed to find start boundary for body part");
        }

    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.lang.String.class, org.snmp4j.PDU.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.snmp.SnmpConverters.toString((org.snmp4j.PDU) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.component.snmp.OIDList.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.snmp.SnmpConverters.toOIDList((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    protected void doInit() throws Exception {
        if (knownProperties == null || knownPrefixes == null) {
             
            EndpointUriFactory factory = getCamelContext().getCamelContextExtension().getEndpointUriFactory(getScheme());
            if (factory == null) {
                throw new IllegalStateException("Cannot find EndpointUriFactory for component: " + getScheme());
            }
            knownProperties = factory.propertyNames();
            knownPrefixes = factory.multiValuePrefixes();
        }
    }

    public Map<String, String> getServiceMetadata() {
        Map<String, String> map = new HashMap<>();
        if (configuration.getClientId() != null) {
            map.put("clientId", configuration.getClientId());
        }
        if (configuration.getUserName() != null) {
            map.put("username", configuration.getUserName());
        }
        return map.isEmpty() ? null : map;
    }

    private DaprOperationResponse getState(Exchange exchange, DaprClient client) {
        String stateStore = configurationOptionsProxy.getStateStore(exchange);
        String key = configurationOptionsProxy.getKey(exchange);
        Map<String, String> metadata = configurationOptionsProxy.getMetadata(exchange);
        StateOptions stateOptions = getStateOptions(exchange);

        GetStateRequest stateRequest = new GetStateRequest(stateStore, key);
        stateRequest.setMetadata(metadata);
        stateRequest.setStateOptions(stateOptions);

        State<byte[]> response = client.getState(stateRequest, TypeRef.get(byte[].class)).block();

        return DaprOperationResponse.create(response);
    }

    public static boolean updateResource(BuildContext buildContext, Path out, String data) {
        try {
            if (FileUtil.updateFile(out, data)) {
                refresh(buildContext, out);
                return true;
            }
        } catch (IOException e) {
            throw new IOError(e);
        }
        return false;
    }

    public Knative.Type getType() {
        Knative.Type answer = this.type;
        if (answer == null) {
            String stringValue = getMetadata(Knative.KNATIVE_TYPE);
            if (stringValue != null) {
                answer = Knative.Type.valueOf(stringValue);
            }
        }

        return answer;
    }

    private Stream<? extends Member> findMethodsForClass(Class<?> c) {
        XmlAccessType accessType;
        if (c.getAnnotation(XmlAccessorType.class) != null && c != outputDefinitionClass) {
            accessType = c.getAnnotation(XmlAccessorType.class).value();
        } else {
            accessType = XmlAccessType.PUBLIC_MEMBER;
        }
        if (accessType == XmlAccessType.FIELD || accessType == XmlAccessType.NONE) {
            return Stream.of(c.getDeclaredMethods()).filter(m -> m.getName().startsWith("set") && m.getParameterCount() == 1)
                    .filter(m -> m.getAnnotation(XmlAttribute.class) != null || m.getAnnotation(XmlElement.class) != null
                            || m.getAnnotation(XmlElementRef.class) != null
                            || m.getAnnotation(XmlValue.class) != null)
                    .sorted(Comparator.comparing(Method::getName));
        } else {
            return Stream.of(c.getDeclaredMethods())
                    .filter(m -> Modifier.isPublic(m.getModifiers()) || accessType == XmlAccessType.PROPERTY)
                    .filter(m -> m.getName().startsWith("set") && m.getParameterCount() == 1)
                    .filter(m -> m.getAnnotation(XmlTransient.class) == null)
                    .sorted(Comparator.comparing(Method::getName));
        }
    }

    private String doLoadJavaSource(String className) {
        try {
            Path file = getSourceRoots().stream()
                    .map(d -> d.resolve(className.replace('.', '/') + ".java"))
                    .filter(Files::isRegularFile)
                    .findFirst()
                    .orElse(null);

             
            if (file == null && className.startsWith("org.apache.camel.support.")) {
                return null;
            }

            if (file == null) {
                throw new FileNotFoundException("Unable to find source for " + className);
            }
            return PackageHelper.loadText(file);
        } catch (IOException e) {
            String classpath;
            try {
                classpath = project.getCompileClasspathElements().toString();
            } catch (Exception e2) {
                classpath = e2.toString();
            }
            throw new RuntimeException(
                    "Unable to load source for class " + className + " in folders " + getSourceRoots()
                                       + " (classpath: " + classpath + ")");
        }
    }

    protected LongUpDownCounter getInstrument(String name, String description) {
        LongUpDownCounter counter = counters.get(name);
        if (counter == null) {
            synchronized (lock) {
                counter = counters.get(name);
                if (counter == null) {
                    Meter meter = getEndpoint().getMeter();
                    LongUpDownCounterBuilder builder = meter.upDownCounterBuilder(name);
                    if (description != null) {
                        builder.setDescription(description);
                    }
                    counter = builder.build();
                    counters.put(name, counter);
                }
            }
        }
        return counter;
    }

    private void processAsynchronously(final Exchange exchange, final ChannelHandlerContext ctx) {
        consumer.getAsyncProcessor().process(exchange, doneSync -> {
             
            try {
                if (consumer.getConfiguration().isSync()) {
                    sendResponse(ctx, exchange);
                }
            } catch (Exception e) {
                consumer.getExceptionHandler().handleException(e);
            } finally {
                consumer.doneUoW(exchange);
                consumer.releaseExchange(exchange, false);
            }
        });
    }

    public int forceDiscardingOfAllGroups() {

         
        boolean allow = camelContext.getStatus().isStarted() || camelContext.getStatus().isStopping();
        if (!allow) {
            LOG.warn("Cannot start force discarding of all groups because CamelContext({}) has not been started",
                    camelContext.getName());
            return 0;
        }

        LOG.trace("Starting force discarding of all groups task");

         
        Set<String> keys = aggregationRepository.getKeys();

        int total = 0;
        if (keys != null && !keys.isEmpty()) {
             
            lock.lock();
            total = keys.size();
            try {
                for (String key : keys) {
                    Exchange exchange = aggregationRepository.get(camelContext, key);
                    if (exchange != null) {
                        LOG.trace("Force discarded triggered for correlation key: {}", key);
                         
                        onCompletion(key, exchange, exchange, false, true);
                    }
                }
            } finally {
                lock.unlock();
            }
        }
        LOG.trace("Completed force discarding of all groups task");

        if (total > 0) {
            LOG.debug("Forcing discarding of all groups with {} exchanges", total);
        }
        return total;
    }

    private static void invokeSynchronizationCallbacks(Route route, Exchange exchange, Logger log, List<Synchronization> copy) {
        for (Synchronization synchronization : copy) {
            final SynchronizationRouteAware routeSynchronization = synchronization.getRouteSynchronization();
            if (routeSynchronization != null) {
                try {
                    log.trace("Invoking synchronization.onBeforeRoute: {} with {}", synchronization, exchange);
                    routeSynchronization.onBeforeRoute(route, exchange);
                } catch (Exception e) {
                     
                    log.warn("Exception occurred during onBeforeRoute. This exception will be ignored.", e);
                }
            }
        }
    }

    public static Map<String, Object> asMap(Node node) {
        if (node == null) {
            return null;
        }

        final MappingNode mn = asMappingNode(node);
        final Map<String, Object> answer = new HashMap<>();

        for (NodeTuple tuple : mn.getValue()) {
            final String key = asText(tuple.getKeyNode());
            final Node val = tuple.getValueNode();

            switch (val.getNodeType()) {
                case SCALAR:
                    answer.put(StringHelper.dashToCamelCase(key), asText(val));
                    break;
                case MAPPING:
                    answer.put(StringHelper.dashToCamelCase(key), asMap(val));
                    break;
                default:
                    throw new UnsupportedNodeTypeException(val);
            }
        }

        return answer;
    }

    private static GenericFileExclusiveReadLockStrategy<File> newStrategyForChanged(
            Map<String, Object> params) {
        GenericFileExclusiveReadLockStrategy<File> strategy;
        FileChangedExclusiveReadLockStrategy readLockStrategy = new FileChangedExclusiveReadLockStrategy();
        Long minLength = (Long) params.get("readLockMinLength");
        if (minLength != null) {
            readLockStrategy.setMinLength(minLength);
        }
        Long minAge = (Long) params.get("readLockMinAge");
        if (null != minAge) {
            readLockStrategy.setMinAge(minAge);
        }
        strategy = readLockStrategy;
        return strategy;
    }

    public BraintreeConfiguration getEndpointConfiguration(BraintreeApiName apiName) {
        BraintreeConfiguration result = null;
        switch (apiName) {
            case ADD_ON:
                result = new AddOnGatewayEndpointConfiguration();
                break;
            case ADDRESS:
                result = new AddressGatewayEndpointConfiguration();
                break;
            case CLIENT_TOKEN:
                result = new ClientTokenGatewayEndpointConfiguration();
                break;
            case CREDIT_CARD_VERIFICATION:
                result = new CreditCardVerificationGatewayEndpointConfiguration();
                break;
            case CUSTOMER:
                result = new CustomerGatewayEndpointConfiguration();
                break;
            case DISCOUNT:
                result = new DiscountGatewayEndpointConfiguration();
                break;
            case DISPUTE:
                result = new DisputeGatewayEndpointConfiguration();
                break;
            case DOCUMENT_UPLOAD:
                result = new DocumentUploadGatewayEndpointConfiguration();
                break;
            case MERCHANT_ACCOUNT:
                result = new MerchantAccountGatewayEndpointConfiguration();
                break;
            case PAYMENT_METHOD:
                result = new PaymentMethodGatewayEndpointConfiguration();
                break;
            case PAYMENT_METHOD_NONCE:
                result = new PaymentMethodNonceGatewayEndpointConfiguration();
                break;
            case OAUTH:
                result = new OAuthGatewayEndpointConfiguration();
                break;
            case PLAN:
                result = new PlanGatewayEndpointConfiguration();
                break;
            case REPORT:
                result = new ReportGatewayEndpointConfiguration();
                break;
            case SETTLEMENT_BATCH_SUMMARY:
                result = new SettlementBatchSummaryGatewayEndpointConfiguration();
                break;
            case SUBSCRIPTION:
                result = new SubscriptionGatewayEndpointConfiguration();
                break;
            case TRANSACTION:
                result = new TransactionGatewayEndpointConfiguration();
                break;
            case US_BANK_ACCOUNT:
                result = new UsBankAccountGatewayEndpointConfiguration();
                break;
            case WEBHOOK_NOTIFICATION:
                result = new WebhookNotificationGatewayEndpointConfiguration();
                break;
        }
        return result;
    }

        protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
            doBeforeParse(element);
            super.doParse(element, parserContext, builder);

             
            Binder<Node> binder;
            try {
                binder = getJaxbContext().createBinder();
            } catch (JAXBException e) {
                throw new BeanDefinitionStoreException("Failed to create the JAXB binder", e);
            }
            Object value = parseUsingJaxb(element, parserContext, binder);

            if (value instanceof CamelRouteTemplateContextFactoryBean) {
                CamelRouteTemplateContextFactoryBean factoryBean = (CamelRouteTemplateContextFactoryBean) value;
                builder.addPropertyValue("routeTemplates", factoryBean.getRouteTemplates());
            }

             
            injectNamespaces(element, binder);
        }

    public IamClient initClient() {
        if (iamClient != null) {
            return iamClient;
        }

         
        if (ObjectHelper.isEmpty(getServiceKeys()) && ObjectHelper.isEmpty(getAccessKey())) {
            throw new IllegalArgumentException("Authentication parameter 'access key (AK)' not found");
        }
        if (ObjectHelper.isEmpty(getServiceKeys()) && ObjectHelper.isEmpty(getSecretKey())) {
            throw new IllegalArgumentException("Authentication parameter 'secret key (SK)' not found");
        }

         
        GlobalCredentials auth = new GlobalCredentials()
                .withAk(getServiceKeys() != null
                        ? getServiceKeys().getAccessKey()
                        : getAccessKey())
                .withSk(getServiceKeys() != null
                        ? getServiceKeys().getSecretKey()
                        : getSecretKey());

         
        HttpConfig httpConfig = HttpConfig.getDefaultHttpConfig();
        httpConfig.withIgnoreSSLVerification(isIgnoreSslVerification());
        if (ObjectHelper.isNotEmpty(getProxyHost())
                && ObjectHelper.isNotEmpty(getProxyPort())) {
            httpConfig.withProxyHost(getProxyHost())
                    .withProxyPort(getProxyPort());

            if (ObjectHelper.isNotEmpty(getProxyUser())) {
                httpConfig.withProxyUsername(getProxyUser());
                if (ObjectHelper.isNotEmpty(getProxyPassword())) {
                    httpConfig.withProxyPassword(getProxyPassword());
                }
            }
        }

         
        if (ObjectHelper.isNotEmpty(getRegion())) {
            return IamClient.newBuilder()
                    .withCredential(auth)
                    .withHttpConfig(httpConfig)
                    .withRegion(IamRegion.valueOf(getRegion()))
                    .build();
        } else {
            throw new IllegalArgumentException("Region not found");
        }
    }

    public boolean process(final Exchange exchange, final AsyncCallback callback) {
        try {
             
            Runnable task = taskFactory.acquire(exchange, callback);

             
            if (exchange.isTransacted()) {
                reactiveExecutor.scheduleQueue(task);
            } else {
                reactiveExecutor.scheduleMain(task);
            }
            return false;
        } catch (Exception e) {
            exchange.setException(e);
            callback.done(true);
            return true;
        }
    }

    public void process(Exchange exchange) {
        if (exchange.getIn().getBody() instanceof int[]) {
            int[] seed = exchange.getIn().getBody(int[].class);
            Image[] result = predict(exchange, seed);
            exchange.getIn().setBody(result);
        } else {
            throw new RuntimeCamelException("Data type is not supported. Body should be int[]");
        }
    }

    public Processor createProcessor() throws Exception {
        Policy policy = resolvePolicy();
        ObjectHelper.notNull(policy, "policy", definition);

         
        policy.beforeWrap(route, definition);

         
        Processor childProcessor = this.createChildProcessor(true);

         
        Processor target = policy.wrap(route, childProcessor);

        if (!(target instanceof Service)) {
             
             
            target = new WrapProcessor(target, childProcessor);
        }
        return target;
    }

    protected void doStart() throws Exception {
        super.doStart();

        if (meterRegistry == null) {
            meterRegistry = MicrometerUtils.getOrCreateMeterRegistry(camelContext.getRegistry(), METRICS_REGISTRY_NAME);
        }

        try {
            MicrometerEventNotifierService registryService = camelContext.hasService(MicrometerEventNotifierService.class);
            if (registryService == null) {
                registryService = new MicrometerEventNotifierService();
                registryService.setMeterRegistry(getMeterRegistry());
                registryService.setPrettyPrint(isPrettyPrint());
                registryService.setSkipCamelInfo(isSkipCamelInfo());
                registryService.setDurationUnit(getDurationUnit());
                registryService.setMatchingTags(Tags.of(KIND, KIND_EXCHANGE));
                camelContext.addService(registryService);
                 
                ServiceHelper.startService(registryService);
            }
        } catch (Exception e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        }
    }

    private boolean doSend(Exchange exchange, AsyncCallback callback) {
        if (isRunAllowed()) {
            getAsyncProcessor().process(exchange, doneSync -> {
                if (exchange.getException() != null) {
                    getExceptionHandler().handleException("Error processing exchange", exchange, exchange.getException());
                }
                callback.done(doneSync);
            });
            return false;
        } else {
            LOG.warn("Consumer not ready to process exchanges. The exchange {} will be discarded", exchange);
            callback.done(true);
            return true;
        }
    }

    public Object copy() {
        try {
            EmbeddedDebeziumConfiguration answer = (EmbeddedDebeziumConfiguration) clone();
             
            Map<String, Object> additionalPropertiesCopy = new HashMap<>(additionalProperties);
            answer.setAdditionalProperties(additionalPropertiesCopy);
            return answer;
        } catch (CloneNotSupportedException e) {
            throw new RuntimeCamelException(e);
        }
    }

    void ethNewFilter(Message message) throws IOException {
        DefaultBlockParameter fromBlock = toDefaultBlockParameter(
                message.getHeader(Web3jConstants.FROM_BLOCK, configuration::getFromBlock, String.class));
        DefaultBlockParameter toBlock
                = toDefaultBlockParameter(message.getHeader(Web3jConstants.TO_BLOCK, configuration::getToBlock, String.class));
        List<String> addresses = message.getHeader(Web3jConstants.ADDRESSES, configuration::getAddresses, List.class);
        List<String> topics = message.getHeader(Web3jConstants.TOPICS, configuration::getTopics, List.class);

        org.web3j.protocol.core.methods.request.EthFilter ethFilter
                = Web3jEndpoint.buildEthFilter(fromBlock, toBlock, addresses, topics);

        Request<?, EthFilter> request = web3j.ethNewFilter(ethFilter);
        setRequestId(message, request);
        EthFilter response = request.send();
        boolean hasError = checkForError(message, response);
        if (!hasError) {
            message.setBody(response.getFilterId());
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.caffeine.cache.CaffeineCacheProducer target = (org.apache.camel.component.caffeine.cache.CaffeineCacheProducer) obj;
        switch (key) {
        case "as_map":
        case "AS_MAP": target.onAsMap(exchange.getMessage()); return null;
        case "cleanup":
        case "CLEANUP": target.onCleanUp(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "invalidate":
        case "INVALIDATE": target.onInvalidate(exchange.getMessage()); return null;
        case "invalidate_all":
        case "INVALIDATE_ALL": target.onInvalidateAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        default: return null;
        }
    }

    private Acceptor createAcceptor(
            Application application, SessionSettings settings,
            MessageStoreFactory messageStoreFactory, LogFactory sessionLogFactory,
            MessageFactory messageFactory, ThreadModel threadModel)
            throws ConfigError {

        Acceptor acceptor;
        if (threadModel == ThreadModel.ThreadPerSession) {
            acceptor = new ThreadedSocketAcceptor(
                    application, messageStoreFactory, settings, sessionLogFactory, messageFactory);
        } else if (threadModel == ThreadModel.ThreadPerConnector) {
            acceptor = new SocketAcceptor(application, messageStoreFactory, settings, sessionLogFactory, messageFactory);
        } else {
            throw new ConfigError("Unknown thread mode: " + threadModel);
        }
        return acceptor;
    }

    public E successor(E e) {
        E elem = higher(e);
        if (elem == null) {
            return null;
        }
        if (seqComparator().successor(elem, e)) {
            return elem;
        }
        return null;
    }

    protected Set<String> resolveDependencies(Path settings, Path profile) throws Exception {
        Set<String> answer = super.resolveDependencies(settings, profile);

         
        answer.removeIf(s -> s.contains("camel-core"));
        answer.removeIf(s -> s.contains("camel-microprofile-health"));

        if (hawtio) {
            answer.add("mvn:org.apache.camel:camel-management");
            answer.add("mvn:io.hawt:hawtio-quarkus:" + hawtioVersion);
        }

        return answer;
    }

    protected void halfOpenCircuit(Route route) {
        try {
            lock.lock();
            resumeOrStartConsumer(route.getConsumer());
            state.set(STATE_HALF_OPEN);
            logState();
        } catch (Exception e) {
            handleException(e);
        } finally {
            lock.unlock();
        }
    }

    public Expression createExpression(
            CamelContext camelContext, Annotation annotation,
            LanguageAnnotation languageAnnotation, Class<?> expressionReturnType) {

        Object[] params = new Object[3];
        Class<?> resultType = getResultType(annotation);
        if (resultType.equals(Object.class)) {
            resultType = expressionReturnType;
        }
        params[0] = resultType;
        if (annotation instanceof Joor) {
            Joor joorAnnotation = (Joor) annotation;
            params[1] = joorAnnotation.preCompile();
            params[2] = joorAnnotation.singleQuotes();
        }
        String expression = getExpressionFromAnnotation(annotation);
        return camelContext.resolveLanguage("joor").createExpression(expression, params);
    }

    private static String readClassFromCamelResource(File file, StringBuilder buffer, BuildContext buildContext)
            throws MojoExecutionException {
         
         
        if (file.isDirectory()) {
            return null;
        }
        String name = file.getName();
        if (name.charAt(0) != '.') {
            if (!buffer.isEmpty()) {
                buffer.append(" ");
            }
            buffer.append(name);
        }

        if (!buildContext.hasDelta(file)) {
             
             
             
             
            return null;
        }

         
        try {
            String text = PackageHelper.loadText(file);
            Map<String, String> map = PackageHelper.parseAsMap(text);
            return map.get("class");
        } catch (IOException e) {
            throw new MojoExecutionException("Failed to read file " + file + ". Reason: " + e, e);
        }
    }

    public Map<String, String> getServiceMetadata() {
        Map<String, String> map = new HashMap<>();
        if (configuration.getClientId() != null) {
            map.put("clientId", configuration.getClientId());
        }
        if (configuration.getUserName() != null) {
            map.put("username", configuration.getUserName());
        }
        return map.isEmpty() ? null : map;
    }

    private void createIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                Response response
                        = keycloakClient.realm(realmName).identityProviders().create((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException(
                    "Create identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    protected Object doEvaluate(Exchange exchange, boolean closeStream) {
        InputStream in = null;
        try {
            if (source != null) {
                in = source.evaluate(exchange, InputStream.class);
            } else {
                in = exchange.getIn().getBody(InputStream.class);
            }
            if (in == null) {
                throw new InvalidPayloadException(exchange, InputStream.class);
            }
             
            String charset = ExchangeHelper.getCharsetName(exchange);
            return createIterator(exchange, in, charset);
        } catch (InvalidPayloadException e) {
            exchange.setException(e);
             
            IOHelper.close(in);
            return null;
        } finally {
            if (closeStream) {
                IOHelper.close(in);
            }
        }
    }

    private void add(Exchange exchange) throws Exception {
        final Message in = exchange.getMessage();

        String collectionName = getCollectionName(in);
        Collection collection = this.client.getCollection(collectionName, embeddingFunction);

        List<String> ids = in.getHeader(ChromaHeaders.IDS, List.class);
        List<Embedding> embeddings = getEmbeddings(in);
        List<Map<String, String>> metadatas = in.getHeader(ChromaHeaders.METADATAS, List.class);
        List<String> documents = in.getBody(List.class);

        collection.add(embeddings, metadatas, documents, ids);
        in.setHeader(ChromaHeaders.OPERATION_STATUS, "SUCCESS");
    }

    public Exchange receiveNoWait(Exchange exchange) {
        if (LOG.isTraceEnabled()) {
            LOG.trace("receiveNoWait polling file: {}", getConsumer().getEndpoint());
        }
        int polled = doReceive(exchange, 0);
        if (polled > 0) {
            return super.receive(0);
        } else {
            return null;
        }
    }

    public SmppMessage createSmppMessage(CamelContext camelContext, AlertNotification alertNotification) {
        SmppMessage smppMessage = new SmppMessage(camelContext, alertNotification, configuration);

        smppMessage.setHeader(SmppConstants.MESSAGE_TYPE, SmppMessageType.AlertNotification.toString());
        smppMessage.setHeader(SmppConstants.SEQUENCE_NUMBER, alertNotification.getSequenceNumber());
        smppMessage.setHeader(SmppConstants.COMMAND_ID, alertNotification.getCommandId());
        smppMessage.setHeader(SmppConstants.COMMAND_STATUS, alertNotification.getCommandStatus());
        smppMessage.setHeader(SmppConstants.SOURCE_ADDR, alertNotification.getSourceAddr());
        smppMessage.setHeader(SmppConstants.SOURCE_ADDR_NPI, alertNotification.getSourceAddrNpi());
        smppMessage.setHeader(SmppConstants.SOURCE_ADDR_TON, alertNotification.getSourceAddrTon());
        smppMessage.setHeader(SmppConstants.ESME_ADDR, alertNotification.getEsmeAddr());
        smppMessage.setHeader(SmppConstants.ESME_ADDR_NPI, alertNotification.getEsmeAddrNpi());
        smppMessage.setHeader(SmppConstants.ESME_ADDR_TON, alertNotification.getEsmeAddrTon());

        return smppMessage;
    }

        protected boolean setPropertyOnComponent(
                Component component,
                String name,
                Object value) {
            switch (name) {
            case "additionalProperties": getOrCreateConfiguration((DebeziumPostgresComponent) component).setAdditionalProperties((java.util.Map) value); return true;
            case "bridgeErrorHandler": ((DebeziumPostgresComponent) component).setBridgeErrorHandler((boolean) value); return true;
            case "configuration": ((DebeziumPostgresComponent) component).setConfiguration((org.apache.camel.component.debezium.postgres.configuration.PostgresConnectorEmbeddedDebeziumConfiguration) value); return true;
            case "internalKeyConverter": getOrCreateConfiguration((DebeziumPostgresComponent) component).setInternalKeyConverter((java.lang.String) value); return true;
            case "internalValueConverter": getOrCreateConfiguration((DebeziumPostgresComponent) component).setInternalValueConverter((java.lang.String) value); return true;
            case "offsetCommitPolicy": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOffsetCommitPolicy((java.lang.String) value); return true;
            case "offsetCommitTimeoutMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOffsetCommitTimeoutMs((long) value); return true;
            case "offsetFlushIntervalMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOffsetFlushIntervalMs((long) value); return true;
            case "offsetStorage": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOffsetStorage((java.lang.String) value); return true;
            case "offsetStorageFileName": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOffsetStorageFileName((java.lang.String) value); return true;
            case "offsetStoragePartitions": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOffsetStoragePartitions((int) value); return true;
            case "offsetStorageReplicationFactor": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOffsetStorageReplicationFactor((int) value); return true;
            case "offsetStorageTopic": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOffsetStorageTopic((java.lang.String) value); return true;
            case "autowiredEnabled": ((DebeziumPostgresComponent) component).setAutowiredEnabled((boolean) value); return true;
            case "binaryHandlingMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setBinaryHandlingMode((java.lang.String) value); return true;
            case "columnExcludeList": getOrCreateConfiguration((DebeziumPostgresComponent) component).setColumnExcludeList((java.lang.String) value); return true;
            case "columnIncludeList": getOrCreateConfiguration((DebeziumPostgresComponent) component).setColumnIncludeList((java.lang.String) value); return true;
            case "columnPropagateSourceType": getOrCreateConfiguration((DebeziumPostgresComponent) component).setColumnPropagateSourceType((java.lang.String) value); return true;
            case "connectionValidationTimeoutMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setConnectionValidationTimeoutMs((long) value); return true;
            case "converters": getOrCreateConfiguration((DebeziumPostgresComponent) component).setConverters((java.lang.String) value); return true;
            case "customMetricTags": getOrCreateConfiguration((DebeziumPostgresComponent) component).setCustomMetricTags((java.lang.String) value); return true;
            case "customSanitizePattern": getOrCreateConfiguration((DebeziumPostgresComponent) component).setCustomSanitizePattern((java.lang.String) value); return true;
            case "databaseDbname": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabaseDbname((java.lang.String) value); return true;
            case "databaseHostname": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabaseHostname((java.lang.String) value); return true;
            case "databaseInitialStatements": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabaseInitialStatements((java.lang.String) value); return true;
            case "databasePassword": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabasePassword((java.lang.String) value); return true;
            case "databasePort": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabasePort((int) value); return true;
            case "databaseQueryTimeoutMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabaseQueryTimeoutMs((int) value); return true;
            case "databaseSslcert": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabaseSslcert((java.lang.String) value); return true;
            case "databaseSslfactory": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabaseSslfactory((java.lang.String) value); return true;
            case "databaseSslkey": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabaseSslkey((java.lang.String) value); return true;
            case "databaseSslmode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabaseSslmode((java.lang.String) value); return true;
            case "databaseSslpassword": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabaseSslpassword((java.lang.String) value); return true;
            case "databaseSslrootcert": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabaseSslrootcert((java.lang.String) value); return true;
            case "databaseTcpkeepalive": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabaseTcpkeepalive((boolean) value); return true;
            case "databaseUser": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatabaseUser((java.lang.String) value); return true;
            case "datatypePropagateSourceType": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDatatypePropagateSourceType((java.lang.String) value); return true;
            case "decimalHandlingMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setDecimalHandlingMode((java.lang.String) value); return true;
            case "errorsMaxRetries": getOrCreateConfiguration((DebeziumPostgresComponent) component).setErrorsMaxRetries((int) value); return true;
            case "eventProcessingFailureHandlingMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setEventProcessingFailureHandlingMode((java.lang.String) value); return true;
            case "executorShutdownTimeoutMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setExecutorShutdownTimeoutMs((long) value); return true;
            case "extendedHeadersEnabled": getOrCreateConfiguration((DebeziumPostgresComponent) component).setExtendedHeadersEnabled((boolean) value); return true;
            case "guardrailCollectionsLimitAction": getOrCreateConfiguration((DebeziumPostgresComponent) component).setGuardrailCollectionsLimitAction((java.lang.String) value); return true;
            case "guardrailCollectionsMax": getOrCreateConfiguration((DebeziumPostgresComponent) component).setGuardrailCollectionsMax((int) value); return true;
            case "heartbeatActionQuery": getOrCreateConfiguration((DebeziumPostgresComponent) component).setHeartbeatActionQuery((java.lang.String) value); return true;
            case "heartbeatIntervalMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setHeartbeatIntervalMs((int) value); return true;
            case "heartbeatTopicsPrefix": getOrCreateConfiguration((DebeziumPostgresComponent) component).setHeartbeatTopicsPrefix((java.lang.String) value); return true;
            case "hstoreHandlingMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setHstoreHandlingMode((java.lang.String) value); return true;
            case "includeSchemaComments": getOrCreateConfiguration((DebeziumPostgresComponent) component).setIncludeSchemaComments((boolean) value); return true;
            case "includeUnknownDatatypes": getOrCreateConfiguration((DebeziumPostgresComponent) component).setIncludeUnknownDatatypes((boolean) value); return true;
            case "incrementalSnapshotChunkSize": getOrCreateConfiguration((DebeziumPostgresComponent) component).setIncrementalSnapshotChunkSize((int) value); return true;
            case "incrementalSnapshotWatermarkingStrategy": getOrCreateConfiguration((DebeziumPostgresComponent) component).setIncrementalSnapshotWatermarkingStrategy((java.lang.String) value); return true;
            case "intervalHandlingMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setIntervalHandlingMode((java.lang.String) value); return true;
            case "lsnFlushMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setLsnFlushMode((java.lang.String) value); return true;
            case "lsnFlushTimeoutAction": getOrCreateConfiguration((DebeziumPostgresComponent) component).setLsnFlushTimeoutAction((java.lang.String) value); return true;
            case "lsnFlushTimeoutMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setLsnFlushTimeoutMs((long) value); return true;
            case "maxBatchSize": getOrCreateConfiguration((DebeziumPostgresComponent) component).setMaxBatchSize((int) value); return true;
            case "maxQueueSize": getOrCreateConfiguration((DebeziumPostgresComponent) component).setMaxQueueSize((int) value); return true;
            case "maxQueueSizeInBytes": getOrCreateConfiguration((DebeziumPostgresComponent) component).setMaxQueueSizeInBytes((long) value); return true;
            case "messageKeyColumns": getOrCreateConfiguration((DebeziumPostgresComponent) component).setMessageKeyColumns((java.lang.String) value); return true;
            case "messagePrefixExcludeList": getOrCreateConfiguration((DebeziumPostgresComponent) component).setMessagePrefixExcludeList((java.lang.String) value); return true;
            case "messagePrefixIncludeList": getOrCreateConfiguration((DebeziumPostgresComponent) component).setMessagePrefixIncludeList((java.lang.String) value); return true;
            case "notificationEnabledChannels": getOrCreateConfiguration((DebeziumPostgresComponent) component).setNotificationEnabledChannels((java.lang.String) value); return true;
            case "notificationSinkTopicName": getOrCreateConfiguration((DebeziumPostgresComponent) component).setNotificationSinkTopicName((java.lang.String) value); return true;
            case "openlineageIntegrationConfigFilePath": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOpenlineageIntegrationConfigFilePath((java.lang.String) value); return true;
            case "openlineageIntegrationDatasetKafkaBootstrapServers": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOpenlineageIntegrationDatasetKafkaBootstrapServers((java.lang.String) value); return true;
            case "openlineageIntegrationEnabled": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOpenlineageIntegrationEnabled((boolean) value); return true;
            case "openlineageIntegrationJobDescription": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOpenlineageIntegrationJobDescription((java.lang.String) value); return true;
            case "openlineageIntegrationJobNamespace": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOpenlineageIntegrationJobNamespace((java.lang.String) value); return true;
            case "openlineageIntegrationJobOwners": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOpenlineageIntegrationJobOwners((java.lang.String) value); return true;
            case "openlineageIntegrationJobTags": getOrCreateConfiguration((DebeziumPostgresComponent) component).setOpenlineageIntegrationJobTags((java.lang.String) value); return true;
            case "pluginName": getOrCreateConfiguration((DebeziumPostgresComponent) component).setPluginName((java.lang.String) value); return true;
            case "pollIntervalMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setPollIntervalMs((long) value); return true;
            case "postProcessors": getOrCreateConfiguration((DebeziumPostgresComponent) component).setPostProcessors((java.lang.String) value); return true;
            case "provideTransactionMetadata": getOrCreateConfiguration((DebeziumPostgresComponent) component).setProvideTransactionMetadata((boolean) value); return true;
            case "publicationAutocreateMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setPublicationAutocreateMode((java.lang.String) value); return true;
            case "publicationName": getOrCreateConfiguration((DebeziumPostgresComponent) component).setPublicationName((java.lang.String) value); return true;
            case "publishViaPartitionRoot": getOrCreateConfiguration((DebeziumPostgresComponent) component).setPublishViaPartitionRoot((boolean) value); return true;
            case "queryFetchSize": getOrCreateConfiguration((DebeziumPostgresComponent) component).setQueryFetchSize((int) value); return true;
            case "replicaIdentityAutosetValues": getOrCreateConfiguration((DebeziumPostgresComponent) component).setReplicaIdentityAutosetValues((java.lang.String) value); return true;
            case "retriableRestartConnectorWaitMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setRetriableRestartConnectorWaitMs((long) value); return true;
            case "schemaExcludeList": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSchemaExcludeList((java.lang.String) value); return true;
            case "schemaHistoryInternalFileFilename": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSchemaHistoryInternalFileFilename((java.lang.String) value); return true;
            case "schemaIncludeList": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSchemaIncludeList((java.lang.String) value); return true;
            case "schemaNameAdjustmentMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSchemaNameAdjustmentMode((java.lang.String) value); return true;
            case "schemaRefreshMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSchemaRefreshMode((java.lang.String) value); return true;
            case "signalDataCollection": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSignalDataCollection((java.lang.String) value); return true;
            case "signalEnabledChannels": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSignalEnabledChannels((java.lang.String) value); return true;
            case "signalPollIntervalMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSignalPollIntervalMs((long) value); return true;
            case "skippedOperations": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSkippedOperations((java.lang.String) value); return true;
            case "slotDropOnStop": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSlotDropOnStop((boolean) value); return true;
            case "slotFailover": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSlotFailover((boolean) value); return true;
            case "slotMaxRetries": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSlotMaxRetries((int) value); return true;
            case "slotName": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSlotName((java.lang.String) value); return true;
            case "slotRetryDelayMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSlotRetryDelayMs((long) value); return true;
            case "slotStreamParams": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSlotStreamParams((java.lang.String) value); return true;
            case "snapshotDelayMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotDelayMs((long) value); return true;
            case "snapshotFetchSize": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotFetchSize((int) value); return true;
            case "snapshotIncludeCollectionList": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotIncludeCollectionList((java.lang.String) value); return true;
            case "snapshotIsolationMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotIsolationMode((java.lang.String) value); return true;
            case "snapshotLockingMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotLockingMode((java.lang.String) value); return true;
            case "snapshotLockingModeCustomName": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotLockingModeCustomName((java.lang.String) value); return true;
            case "snapshotLockTimeoutMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotLockTimeoutMs((long) value); return true;
            case "snapshotMaxThreads": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotMaxThreads((int) value); return true;
            case "snapshotMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotMode((java.lang.String) value); return true;
            case "snapshotModeConfigurationBasedSnapshotData": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotModeConfigurationBasedSnapshotData((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotOnDataError": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotModeConfigurationBasedSnapshotOnDataError((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotOnSchemaError": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotModeConfigurationBasedSnapshotOnSchemaError((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotSchema": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotModeConfigurationBasedSnapshotSchema((boolean) value); return true;
            case "snapshotModeConfigurationBasedStartStream": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotModeConfigurationBasedStartStream((boolean) value); return true;
            case "snapshotModeCustomName": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotModeCustomName((java.lang.String) value); return true;
            case "snapshotQueryMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotQueryMode((java.lang.String) value); return true;
            case "snapshotQueryModeCustomName": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotQueryModeCustomName((java.lang.String) value); return true;
            case "snapshotSelectStatementOverrides": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotSelectStatementOverrides((java.lang.String) value); return true;
            case "snapshotTablesOrderByRowCount": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSnapshotTablesOrderByRowCount((java.lang.String) value); return true;
            case "sourceinfoStructMaker": getOrCreateConfiguration((DebeziumPostgresComponent) component).setSourceinfoStructMaker((java.lang.String) value); return true;
            case "statusUpdateIntervalMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setStatusUpdateIntervalMs((int) value); return true;
            case "streamingDelayMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setStreamingDelayMs((long) value); return true;
            case "tableExcludeList": getOrCreateConfiguration((DebeziumPostgresComponent) component).setTableExcludeList((java.lang.String) value); return true;
            case "tableIgnoreBuiltin": getOrCreateConfiguration((DebeziumPostgresComponent) component).setTableIgnoreBuiltin((boolean) value); return true;
            case "tableIncludeList": getOrCreateConfiguration((DebeziumPostgresComponent) component).setTableIncludeList((java.lang.String) value); return true;
            case "timePrecisionMode": getOrCreateConfiguration((DebeziumPostgresComponent) component).setTimePrecisionMode((java.lang.String) value); return true;
            case "tombstonesOnDelete": getOrCreateConfiguration((DebeziumPostgresComponent) component).setTombstonesOnDelete((boolean) value); return true;
            case "topicNamingStrategy": getOrCreateConfiguration((DebeziumPostgresComponent) component).setTopicNamingStrategy((java.lang.String) value); return true;
            case "topicPrefix": getOrCreateConfiguration((DebeziumPostgresComponent) component).setTopicPrefix((java.lang.String) value); return true;
            case "transactionMetadataFactory": getOrCreateConfiguration((DebeziumPostgresComponent) component).setTransactionMetadataFactory((java.lang.String) value); return true;
            case "unavailableValuePlaceholder": getOrCreateConfiguration((DebeziumPostgresComponent) component).setUnavailableValuePlaceholder((java.lang.String) value); return true;
            case "xminFetchIntervalMs": getOrCreateConfiguration((DebeziumPostgresComponent) component).setXminFetchIntervalMs((long) value); return true;
            default: return false;
            }
        }

    public String getEndpointUri() {
        if (endpointProducerBuilder != null) {
            return endpointProducerBuilder.getRawUri();
        } else if (endpoint != null) {
            return endpoint.getEndpointUri();
        } else {
            return uri;
        }
    }

    private MessageStoreFactory inferMessageStoreFactory(SessionSettings settings) throws ConfigError {
        Set<MessageStoreFactory> impliedMessageStoreFactories = new HashSet<>();
        isJdbcStore(settings, impliedMessageStoreFactories);
        isFileStore(settings, impliedMessageStoreFactories);
        isSleepycatStore(settings, impliedMessageStoreFactories);
        if (impliedMessageStoreFactories.size() > 1) {
            throw new ConfigError("Ambiguous message store implied in configuration.");
        }
        MessageStoreFactory messageStoreFactory;
        if (impliedMessageStoreFactories.size() == 1) {
            messageStoreFactory = impliedMessageStoreFactories.iterator().next();
        } else {
            messageStoreFactory = new MemoryStoreFactory();
        }
        LOG.info("Inferring message store factory: {}", messageStoreFactory.getClass().getName());
        return messageStoreFactory;
    }

    public DocFlavor forMimeTypeUTF8(String flavor, String mimeType) {
        if (mimeType.equalsIgnoreCase("TEXT_HTML_UTF_16BE")) {
            if (flavor.equalsIgnoreCase("DocFlavor.BYTE_ARRAY")) {
                d = DocFlavor.BYTE_ARRAY.TEXT_HTML_UTF_8;
            } else if (flavor.equalsIgnoreCase("DocFlavor.INPUT_STREAM")) {
                d = DocFlavor.INPUT_STREAM.TEXT_HTML_UTF_8;
            } else if (flavor.equalsIgnoreCase("DocFlavor.URL")) {
                d = DocFlavor.URL.TEXT_HTML_UTF_8;
            }
        } else {
            if (flavor.equalsIgnoreCase("DocFlavor.BYTE_ARRAY")) {
                d = DocFlavor.BYTE_ARRAY.TEXT_PLAIN_UTF_8;
            } else if (flavor.equalsIgnoreCase("DocFlavor.INPUT_STREAM")) {
                d = DocFlavor.INPUT_STREAM.TEXT_PLAIN_UTF_8;
            } else if (flavor.equalsIgnoreCase("DocFlavor.URL")) {
                d = DocFlavor.URL.TEXT_PLAIN_UTF_8;
            }
        }

        return d;
    }

        public CamelPostProcessorHelper getPostProcessorHelper() {
             
            if (camelPostProcessorHelper == null) {
                camelPostProcessorHelper = new CamelPostProcessorHelper(camelContext) {

                    @Override
                    public CamelContext getCamelContext() {
                        CamelContext answer = CamelBeanPostProcessor.this.camelContext;
                        if (answer == null) {
                             
                             
                             
                             
                            answer = delegate.getOrLookupCamelContext();
                        }
                        return answer;
                    }

                    @Override
                    protected RuntimeException createProxyInstantiationRuntimeException(
                            Class<?> type, Endpoint endpoint, Exception e) {
                        return new BeanInstantiationException(
                                type, "Could not instantiate proxy of type " + type.getName() + " on endpoint " + endpoint, e);
                    }

                    @Override
                    protected boolean isSingleton(Object bean, String beanName) {
                         
                         
                        if (applicationContext == null || beanName == null) {
                            return super.isSingleton(bean, beanName);
                        } else {
                            return applicationContext.isSingleton(beanName);
                        }
                    }

                    @Override
                    protected void startService(Service service, CamelContext context, Object bean, String beanName)
                            throws Exception {
                        if (isSingleton(bean, beanName)) {
                            getCamelContext().addService(service);
                        } else {
                             
                            ServiceHelper.startService(service);
                            if (prototypeBeans.add(beanName)) {
                                 
                                CamelBeanPostProcessor.LOG
                                        .warn("The bean with id [{}] is prototype scoped and cannot stop the injected "
                                              + " service when bean is destroyed: {}. You may want to stop the service "
                                              + "manually from the bean.", beanName, service);
                            }
                        }
                    }
                };
            }
            return camelPostProcessorHelper;
        }

                public void onFailure(Exchange exchange) {
                    final String key = exchange.getProperty(AWS2S3Constants.KEY, String.class);
                    try {
                        processRollback(exchange);
                    } finally {
                        if (key != null) {
                            getEndpoint().getInProgressRepository().remove(key);
                        }
                    }
                }

    public boolean hasNext() {
        if (closed) {
            return false;
        }

        boolean hasNext = currentSearchHits.hasNext();
        if (!hasNext) {
            updateCurrentSearchHits();

            hasNext = currentSearchHits.hasNext();
        }

        return hasNext;
    }

    public String getComponentJSonSchema(String name) {
        final String file = camelCatalog.getRuntimeProvider().getComponentJSonSchemaDirectory() + "/" + name + EXTENSION;

        final String fromVersionManager = loadResourceFromVersionManager(file);
        if (fromVersionManager != null) {
            return fromVersionManager;
        }

         
        final String answer = extraComponentsJSonSchema.get(name);
        if (answer != null) {
            return answer;
        }

         
        final String className = extraComponents.get(name);
        return loadFromClasspath(className, name);
    }

    protected void prepareDataFormatConfig(Map<String, Object> properties) {
        properties.put("prettyPrint", definition.getPrettyPrint());
        properties.put("objectFactory", definition.getObjectFactory());
        properties.put("ignoreJAXBElement", definition.getIgnoreJAXBElement());
        properties.put("mustBeJAXBElement", definition.getMustBeJAXBElement());
        properties.put("filterNonXmlChars", definition.getFilterNonXmlChars());
        properties.put("fragment", definition.getFragment());
        properties.put("contextPath", definition.getContextPath());
        properties.put("contextPathIsClassName", definition.getContextPathIsClassName());
        properties.put("partClass", definition.getPartClass());
        properties.put("partNamespace", definition.getPartNamespace());
        properties.put("encoding", definition.getEncoding());
        properties.put("namespacePrefix", asRef(definition.getNamespacePrefix()));
        properties.put("schema", definition.getSchema());
        properties.put("schemaSeverityLevel", definition.getSchemaSeverityLevel());
        properties.put("xmlStreamWriterWrapper", definition.getXmlStreamWriterWrapper());
        properties.put("schemaLocation", definition.getSchemaLocation());
        properties.put("noNamespaceSchemaLocation", definition.getNoNamespaceSchemaLocation());
        properties.put("jaxbProviderProperties", definition.getJaxbProviderProperties());
        properties.put("accessExternalSchemaProtocols", definition.getAccessExternalSchemaProtocols());
    }

    public boolean acquireExclusiveReadLock(
            GenericFileOperations<FTPFile> operations, GenericFile<FTPFile> file, Exchange exchange)
            throws Exception {
        LOG.trace("Waiting for exclusive read lock to file: {}", file);

        BlockingTask task = Tasks.foregroundTask()
                .withBudget(Budgets.iterationTimeBudget()
                        .withMaxDuration(Duration.ofMillis(timeout))
                        .withInterval(Duration.ofMillis(checkInterval))
                        .build())
                .withName("ftp-acquire-exclusive-read-lock")
                .build();

        ExclusiveReadLockCheck exclusiveReadLockCheck = new ExclusiveReadLockCheck(fastExistsCheck, minAge, minLength);

        if (!task.run(exchange.getContext(), () -> exclusiveReadLockCheck.tryAcquireExclusiveReadLock(operations, file))) {
            CamelLogger.log(LOG, readLockLoggingLevel,
                    "Cannot acquire read lock within " + timeout + " millis. Will skip the file: " + file);

            return false;
        }

        return true;
    }

    private void deleteFunction(CloudFunctionsServiceClient client, Exchange exchange)
            throws InvalidPayloadException, InterruptedException, ExecutionException {
        Empty response = null;
        if (getConfiguration().isPojoRequest()) {
            DeleteFunctionRequest request = exchange.getIn().getMandatoryBody(DeleteFunctionRequest.class);
            response = client.deleteFunctionAsync(request).get();
        } else {
            CloudFunctionName cfName = CloudFunctionName.of(getConfiguration().getProject(),
                    getConfiguration().getLocation(), getConfiguration().getFunctionName());
            DeleteFunctionRequest request = DeleteFunctionRequest.newBuilder().setName(cfName.toString()).build();
            response = client.deleteFunctionAsync(request).get();
        }
        Message message = getMessageForResponse(exchange);
        message.setBody(response);
    }

    private static String pathAsKey(String path) {
         
        if (path == null || path.equals("/")) {
            path = "";
        }

         
        path = StringHelper.before(path, "?", path);

         
        if (path.endsWith("/")) {
            path = path.substring(0, path.length() - 1);
        }

        return UnsafeUriCharactersEncoder.encodeHttpURI(path);
    }

        public void run() {
            FilterWatchListDeletable<HorizontalPodAutoscaler, HorizontalPodAutoscalerList, Resource<HorizontalPodAutoscaler>> w;

             
            String namespace = getEndpoint().getKubernetesConfiguration().getNamespace();
            String labelKey = getEndpoint().getKubernetesConfiguration().getLabelKey();
            String labelValue = getEndpoint().getKubernetesConfiguration().getLabelValue();
            String resourceName = getEndpoint().getKubernetesConfiguration().getResourceName();

            if (ObjectHelper.isEmpty(namespace)) {
                w = getEndpoint().getKubernetesClient().autoscaling().v1().horizontalPodAutoscalers().inAnyNamespace();

                if (ObjectHelper.isNotEmpty(labelKey) && ObjectHelper.isNotEmpty(labelValue)) {
                    w = w.withLabel(labelKey, labelValue);
                }
            } else {
                final NonNamespaceOperation<HorizontalPodAutoscaler, HorizontalPodAutoscalerList, Resource<HorizontalPodAutoscaler>> client
                        = getEndpoint().getKubernetesClient().autoscaling().v1().horizontalPodAutoscalers()
                                .inNamespace(namespace);
                w = client;
                if (ObjectHelper.isNotEmpty(labelKey) && ObjectHelper.isNotEmpty(labelValue)) {
                    w = client.withLabel(labelKey, labelValue);
                } else if (ObjectHelper.isNotEmpty(resourceName)) {
                    w = (FilterWatchListDeletable<HorizontalPodAutoscaler, HorizontalPodAutoscalerList, Resource<HorizontalPodAutoscaler>>) client
                            .withName(resourceName);
                }
            }

            watch = w.watch(new Watcher<>() {

                @Override
                public void eventReceived(Action action, HorizontalPodAutoscaler resource) {
                    Exchange exchange = createExchange(false);
                    exchange.getIn().setBody(resource);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_ACTION, action);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_TIMESTAMP, System.currentTimeMillis());
                    try {
                        processor.process(exchange);
                    } catch (Exception e) {
                        getExceptionHandler().handleException("Error during processing", exchange, e);
                    } finally {
                        releaseExchange(exchange, false);
                    }
                }

                @Override
                public void onClose(WatcherException cause) {
                    if (cause != null) {
                        LOG.error(cause.getMessage(), cause);
                    }

                }
            });
        }

    private void queryById(Exchange exchange) throws Exception {
        final Message in = exchange.getMessage();
        String indexId = ExchangeHelper.getMandatoryHeader(exchange, WeaviateVectorDbHeaders.INDEX_ID, String.class);

         
         
        String collectionName;
        if (in.getHeader(WeaviateVectorDbHeaders.COLLECTION_NAME, String.class) != null) {
            collectionName = in.getHeader(WeaviateVectorDbHeaders.COLLECTION_NAME, String.class);
        } else {
            collectionName = getEndpoint().getCollection();
        }

        Result<List<WeaviateObject>> result = client.data().objectsGetter()
                .withClassName(collectionName)
                .withID(indexId)
                .run();

        populateResponse(result, exchange);
    }

    public void process(Exchange exchange) throws Exception {
        if (exchange.getIn().getBody() instanceof TimeSeriesData) {
            TimeSeriesData input = exchange.getIn().getBody(TimeSeriesData.class);
            Forecast result = predict(exchange, input);
            exchange.getIn().setBody(result);
        } else {
            throw new RuntimeCamelException("Data type is not supported. Body should be TimeSeriesData");
        }
    }

    private Consumer<CosmosContainerResponse> setCosmosContainerResponseOnExchange(final Exchange exchange) {
        return response -> {
            if (ObjectHelper.isNotEmpty(response.getProperties())) {
                setMessageHeader(exchange, CosmosDbConstants.RESOURCE_ID, response.getProperties().getResourceId());
                setMessageHeader(exchange, CosmosDbConstants.E_TAG, response.getProperties().getETag());
                setMessageHeader(exchange, CosmosDbConstants.TIMESTAMP, response.getProperties().getTimestamp());
                setMessageHeader(exchange, CosmosDbConstants.DEFAULT_TIME_TO_LIVE_SECONDS,
                        response.getProperties().getDefaultTimeToLiveInSeconds());
            }
            setCommonResponseOnExchange(exchange, response);
        };
    }

        protected boolean setPropertyOnComponent(
                Component component,
                String name,
                Object value) {
            switch (name) {
            case "additionalProperties": getOrCreateConfiguration((DebeziumMongodbComponent) component).setAdditionalProperties((java.util.Map) value); return true;
            case "bridgeErrorHandler": ((DebeziumMongodbComponent) component).setBridgeErrorHandler((boolean) value); return true;
            case "configuration": ((DebeziumMongodbComponent) component).setConfiguration((org.apache.camel.component.debezium.mongodb.configuration.MongoDbConnectorEmbeddedDebeziumConfiguration) value); return true;
            case "internalKeyConverter": getOrCreateConfiguration((DebeziumMongodbComponent) component).setInternalKeyConverter((java.lang.String) value); return true;
            case "internalValueConverter": getOrCreateConfiguration((DebeziumMongodbComponent) component).setInternalValueConverter((java.lang.String) value); return true;
            case "offsetCommitPolicy": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetCommitPolicy((java.lang.String) value); return true;
            case "offsetCommitTimeoutMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetCommitTimeoutMs((long) value); return true;
            case "offsetFlushIntervalMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetFlushIntervalMs((long) value); return true;
            case "offsetStorage": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetStorage((java.lang.String) value); return true;
            case "offsetStorageFileName": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetStorageFileName((java.lang.String) value); return true;
            case "offsetStoragePartitions": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetStoragePartitions((int) value); return true;
            case "offsetStorageReplicationFactor": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetStorageReplicationFactor((int) value); return true;
            case "offsetStorageTopic": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetStorageTopic((java.lang.String) value); return true;
            case "autowiredEnabled": ((DebeziumMongodbComponent) component).setAutowiredEnabled((boolean) value); return true;
            case "captureMode": getOrCreateConfiguration((DebeziumMongodbComponent) component).setCaptureMode((java.lang.String) value); return true;
            case "collectionExcludeList": getOrCreateConfiguration((DebeziumMongodbComponent) component).setCollectionExcludeList((java.lang.String) value); return true;
            case "collectionIncludeList": getOrCreateConfiguration((DebeziumMongodbComponent) component).setCollectionIncludeList((java.lang.String) value); return true;
            case "connectionValidationTimeoutMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setConnectionValidationTimeoutMs((long) value); return true;
            case "converters": getOrCreateConfiguration((DebeziumMongodbComponent) component).setConverters((java.lang.String) value); return true;
            case "cursorMaxAwaitTimeMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setCursorMaxAwaitTimeMs((int) value); return true;
            case "customMetricTags": getOrCreateConfiguration((DebeziumMongodbComponent) component).setCustomMetricTags((java.lang.String) value); return true;
            case "customSanitizePattern": getOrCreateConfiguration((DebeziumMongodbComponent) component).setCustomSanitizePattern((java.lang.String) value); return true;
            case "databaseExcludeList": getOrCreateConfiguration((DebeziumMongodbComponent) component).setDatabaseExcludeList((java.lang.String) value); return true;
            case "databaseIncludeList": getOrCreateConfiguration((DebeziumMongodbComponent) component).setDatabaseIncludeList((java.lang.String) value); return true;
            case "errorsMaxRetries": getOrCreateConfiguration((DebeziumMongodbComponent) component).setErrorsMaxRetries((int) value); return true;
            case "eventProcessingFailureHandlingMode": getOrCreateConfiguration((DebeziumMongodbComponent) component).setEventProcessingFailureHandlingMode((java.lang.String) value); return true;
            case "executorShutdownTimeoutMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setExecutorShutdownTimeoutMs((long) value); return true;
            case "extendedHeadersEnabled": getOrCreateConfiguration((DebeziumMongodbComponent) component).setExtendedHeadersEnabled((boolean) value); return true;
            case "fieldExcludeList": getOrCreateConfiguration((DebeziumMongodbComponent) component).setFieldExcludeList((java.lang.String) value); return true;
            case "fieldRenames": getOrCreateConfiguration((DebeziumMongodbComponent) component).setFieldRenames((java.lang.String) value); return true;
            case "guardrailCollectionsLimitAction": getOrCreateConfiguration((DebeziumMongodbComponent) component).setGuardrailCollectionsLimitAction((java.lang.String) value); return true;
            case "guardrailCollectionsMax": getOrCreateConfiguration((DebeziumMongodbComponent) component).setGuardrailCollectionsMax((int) value); return true;
            case "heartbeatIntervalMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setHeartbeatIntervalMs((int) value); return true;
            case "heartbeatTopicsPrefix": getOrCreateConfiguration((DebeziumMongodbComponent) component).setHeartbeatTopicsPrefix((java.lang.String) value); return true;
            case "incrementalSnapshotWatermarkingStrategy": getOrCreateConfiguration((DebeziumMongodbComponent) component).setIncrementalSnapshotWatermarkingStrategy((java.lang.String) value); return true;
            case "maxBatchSize": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMaxBatchSize((int) value); return true;
            case "maxQueueSize": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMaxQueueSize((int) value); return true;
            case "maxQueueSizeInBytes": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMaxQueueSizeInBytes((long) value); return true;
            case "mongodbAuthsource": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbAuthsource((java.lang.String) value); return true;
            case "mongodbConnectionString": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbConnectionString((java.lang.String) value); return true;
            case "mongodbConnectTimeoutMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbConnectTimeoutMs((int) value); return true;
            case "mongodbHeartbeatFrequencyMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbHeartbeatFrequencyMs((int) value); return true;
            case "mongodbPassword": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbPassword((java.lang.String) value); return true;
            case "mongodbPollIntervalMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbPollIntervalMs((long) value); return true;
            case "mongodbServerSelectionTimeoutMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbServerSelectionTimeoutMs((int) value); return true;
            case "mongodbSocketTimeoutMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbSocketTimeoutMs((int) value); return true;
            case "mongodbSslEnabled": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbSslEnabled((boolean) value); return true;
            case "mongodbSslInvalidHostnameAllowed": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbSslInvalidHostnameAllowed((boolean) value); return true;
            case "mongodbUser": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbUser((java.lang.String) value); return true;
            case "notificationEnabledChannels": getOrCreateConfiguration((DebeziumMongodbComponent) component).setNotificationEnabledChannels((java.lang.String) value); return true;
            case "notificationSinkTopicName": getOrCreateConfiguration((DebeziumMongodbComponent) component).setNotificationSinkTopicName((java.lang.String) value); return true;
            case "openlineageIntegrationConfigFilePath": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationConfigFilePath((java.lang.String) value); return true;
            case "openlineageIntegrationDatasetKafkaBootstrapServers": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationDatasetKafkaBootstrapServers((java.lang.String) value); return true;
            case "openlineageIntegrationEnabled": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationEnabled((boolean) value); return true;
            case "openlineageIntegrationJobDescription": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationJobDescription((java.lang.String) value); return true;
            case "openlineageIntegrationJobNamespace": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationJobNamespace((java.lang.String) value); return true;
            case "openlineageIntegrationJobOwners": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationJobOwners((java.lang.String) value); return true;
            case "openlineageIntegrationJobTags": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationJobTags((java.lang.String) value); return true;
            case "pollIntervalMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setPollIntervalMs((long) value); return true;
            case "postProcessors": getOrCreateConfiguration((DebeziumMongodbComponent) component).setPostProcessors((java.lang.String) value); return true;
            case "provideTransactionMetadata": getOrCreateConfiguration((DebeziumMongodbComponent) component).setProvideTransactionMetadata((boolean) value); return true;
            case "queryFetchSize": getOrCreateConfiguration((DebeziumMongodbComponent) component).setQueryFetchSize((int) value); return true;
            case "retriableRestartConnectorWaitMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setRetriableRestartConnectorWaitMs((long) value); return true;
            case "schemaHistoryInternalFileFilename": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSchemaHistoryInternalFileFilename((java.lang.String) value); return true;
            case "schemaNameAdjustmentMode": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSchemaNameAdjustmentMode((java.lang.String) value); return true;
            case "signalDataCollection": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSignalDataCollection((java.lang.String) value); return true;
            case "signalEnabledChannels": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSignalEnabledChannels((java.lang.String) value); return true;
            case "signalPollIntervalMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSignalPollIntervalMs((long) value); return true;
            case "skippedOperations": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSkippedOperations((java.lang.String) value); return true;
            case "snapshotCollectionFilterOverrides": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotCollectionFilterOverrides((java.lang.String) value); return true;
            case "snapshotDelayMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotDelayMs((long) value); return true;
            case "snapshotFetchSize": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotFetchSize((int) value); return true;
            case "snapshotIncludeCollectionList": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotIncludeCollectionList((java.lang.String) value); return true;
            case "snapshotMaxThreads": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotMaxThreads((int) value); return true;
            case "snapshotMode": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotMode((java.lang.String) value); return true;
            case "snapshotModeConfigurationBasedSnapshotData": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotModeConfigurationBasedSnapshotData((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotOnDataError": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotModeConfigurationBasedSnapshotOnDataError((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotOnSchemaError": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotModeConfigurationBasedSnapshotOnSchemaError((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotSchema": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotModeConfigurationBasedSnapshotSchema((boolean) value); return true;
            case "snapshotModeConfigurationBasedStartStream": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotModeConfigurationBasedStartStream((boolean) value); return true;
            case "snapshotModeCustomName": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotModeCustomName((java.lang.String) value); return true;
            case "sourceinfoStructMaker": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSourceinfoStructMaker((java.lang.String) value); return true;
            case "streamingDelayMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setStreamingDelayMs((long) value); return true;
            case "tombstonesOnDelete": getOrCreateConfiguration((DebeziumMongodbComponent) component).setTombstonesOnDelete((boolean) value); return true;
            case "topicNamingStrategy": getOrCreateConfiguration((DebeziumMongodbComponent) component).setTopicNamingStrategy((java.lang.String) value); return true;
            case "topicPrefix": getOrCreateConfiguration((DebeziumMongodbComponent) component).setTopicPrefix((java.lang.String) value); return true;
            case "transactionMetadataFactory": getOrCreateConfiguration((DebeziumMongodbComponent) component).setTransactionMetadataFactory((java.lang.String) value); return true;
            default: return false;
            }
        }

    protected void afterConfigureProperties() {
        olingo2endpointPropertyNames
                = new HashSet<>(getPropertiesHelper().getValidEndpointProperties(getCamelContext(), configuration));
        olingo2endpointPropertyNames.add(EDM_PROPERTY);
        olingo2endpointPropertyNames.add(ENDPOINT_HTTP_HEADERS_PROPERTY);
        olingo2endpointPropertyNames.add(SERVICE_URI_PROPERTY);
        olingo2endpointPropertyNames.add(FILTER_ALREADY_SEEN);

         
        if (!(READ_METHOD.equals(methodName) || DELETE_METHOD.equals(methodName) || UREAD_METHOD.equals(methodName))
                && inBody == null) {
            inBody = DATA_PROPERTY;
        }
        createProxy();
    }

    private Volume messageToVolume(Message message) {
        Volume volume = message.getBody(Volume.class);
        if (volume == null) {
            Map headers = message.getHeaders();
            VolumeBuilder builder = Builders.volume();

            final String name = message.getHeader(OpenstackConstants.NAME, String.class);
            StringHelper.notEmpty(name, "Name ");
            builder.name(name);

            if (headers.containsKey(OpenstackConstants.DESCRIPTION)) {
                builder.description(message.getHeader(OpenstackConstants.DESCRIPTION, String.class));
            }

            if (headers.containsKey(CinderConstants.SIZE)) {
                builder.size(message.getHeader(CinderConstants.SIZE, Integer.class));
            }

            if (headers.containsKey(CinderConstants.VOLUME_TYPE)) {
                builder.volumeType(message.getHeader(CinderConstants.VOLUME_TYPE, String.class));
            }

            if (headers.containsKey(CinderConstants.IMAGE_REF)) {
                builder.imageRef(message.getHeader(CinderConstants.IMAGE_REF, String.class));
            }

            if (headers.containsKey(CinderConstants.SNAPSHOT_ID)) {
                builder.snapshot(message.getHeader(CinderConstants.SNAPSHOT_ID, String.class));
            }

            if (headers.containsKey(CinderConstants.IS_BOOTABLE)) {
                builder.bootable(message.getHeader(CinderConstants.IS_BOOTABLE, Boolean.class));
            }

            volume = builder.build();
        }

        return volume;
    }

    private void stopConsumer(Route route) {
        lock.lock();
        try {
            if (!suspendedRoutes.contains(route)) {
                LOGGER.debug("Stopping consumer for {} ({})", route.getId(), route.getConsumer());
                stopConsumer(route.getConsumer());
                suspendedRoutes.add(route);
            }
        } catch (Exception e) {
            handleException(e);
        } finally {
            lock.unlock();
        }
    }

    protected JsonObject doCallJson(Map<String, Object> options) {
        JsonObject root = new JsonObject();
        if (propertiesFunction != null) {
            KubernetesClient client = propertiesFunction.getClient();
            if (client != null && client.getMasterUrl() != null) {
                root.put("masterUrl", client.getMasterUrl().toString());
                root.put("login", "OAuth Token");
            }
        }
        KubernetesVaultConfiguration kubernetes = getCamelContext().getVaultConfiguration().getKubernetesVaultConfiguration();
        if (kubernetes != null) {
            root.put("refreshEnabled", kubernetes.isRefreshEnabled());
        }
        if (secretsRefreshTask != null) {
            Instant start = secretsRefreshTask.getStartingTime();
            if (start != null) {
                long timestamp = start.toEpochMilli();
                root.put("startCheckTimestamp", timestamp);
            }
        }
        JsonArray arr = new JsonArray();
        root.put("secrets", arr);

        List<String> sorted = new ArrayList<>(List.of(kubernetes.getSecrets().split(",")));
        Collections.sort(sorted);

        for (String sec : sorted) {
            JsonObject jo = new JsonObject();
            jo.put("name", sec);
            arr.add(jo);
        }
        return root;
    }

    protected int poll() throws Exception {
        Object feed = createFeed();
        if (feed != null) {
            Exchange exchange = endpoint.createExchange(feed);
            getProcessor().process(exchange);
            return 1;
        } else {
            return 0;
        }
    }

    protected void doStart() throws Exception {
        super.doStart();
        final SalesforceEndpointConfig configuration = endpoint.getConfiguration();
        final String apiVersion = configuration.getApiVersion();

        compositeClient = new DefaultCompositeSObjectCollectionsApiClient(
                configuration, apiVersion, session, httpClient, loginConfig);

        if (classMap == null) {
            this.classMap = endpoint.getComponent().getClassMap();
        }
        ServiceHelper.startService(compositeClient);
    }

    protected void doStart() throws Exception {
        ObjectHelper.notNull(camelContext, "camelContext");
        ObjectHelper.notNull(configuration, "configuration");

        if (cache != null) {
            cacheManager = new JCacheManager<>(cache);
        } else {
            cacheManager = JCacheHelper.createManager(getCamelContext(), configuration);
            cache = cacheManager.getCache();
        }
    }

    public AS2Configuration getEndpointConfiguration(AS2ApiName apiName) {
        AS2Configuration result = null;
        switch (apiName) {
            case CLIENT:
                result = new AS2ClientManagerEndpointConfiguration();
                break;
            case SERVER:
                result = new AS2ServerManagerEndpointConfiguration();
                break;
            case RECEIPT:
                result = new AS2AsyncMDNServerManagerEndpointConfiguration();
                break;
        }
        return result;
    }

    public <T> T convertTo(Class<?> from, Class<T> to, Exchange exchange, Object value) throws TypeConversionException {
        try {
            Object obj = doConvertTo(from, to, exchange, value);
            return (T) obj;
        } catch (TypeConversionException e) {
            throw e;
        } catch (Exception e) {
            throw new TypeConversionException(value, to, e);
        }
    }

    public void setPublicKeyName(String publicKeyName) {
        if (context != null && publicKeyName != null) {
            PublicKey pk = context.getRegistry().lookupByNameAndType(publicKeyName, PublicKey.class);
            if (pk != null) {
                setPublicKey(pk);
            }
        }
        if (publicKeyName != null) {
            this.publicKeyName = publicKeyName;
        }
    }

    protected void doListHPAByLabel(Exchange exchange) {
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        Map<String, String> labels = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_HPA_LABELS, Map.class);
        HorizontalPodAutoscalerList hpaList;

        if (ObjectHelper.isEmpty(labels)) {
            LOG.error("Get HPA by labels require specify a labels set");
            throw new IllegalArgumentException("Get HPA by labels require specify a labels set");
        }

        if (ObjectHelper.isEmpty(namespace)) {
            hpaList = getEndpoint().getKubernetesClient().autoscaling().v1().horizontalPodAutoscalers().inAnyNamespace()
                    .withLabels(labels).list();
        } else {
            hpaList = getEndpoint().getKubernetesClient().autoscaling().v1().horizontalPodAutoscalers().inNamespace(namespace)
                    .withLabels(labels).list();
        }

        prepareOutboundMessage(exchange, hpaList.getItems());
    }

    private AlgorithmParameterSpec getDefaultParameterSpec(String algorithm) {
         
        try {
            switch (algorithm) {
                case "DILITHIUM":
                    return org.bouncycastle.pqc.jcajce.spec.DilithiumParameterSpec.dilithium2;
                case "MLDSA":
                case "SLHDSA":
                     
                    return null;
                case "FALCON":
                    return org.bouncycastle.pqc.jcajce.spec.FalconParameterSpec.falcon_512;
                case "SPHINCSPLUS":
                    return org.bouncycastle.pqc.jcajce.spec.SPHINCSPlusParameterSpec.sha2_128s;
                case "XMSS":
                    return new org.bouncycastle.pqc.jcajce.spec.XMSSParameterSpec(
                            10,
                            org.bouncycastle.pqc.jcajce.spec.XMSSParameterSpec.SHA256);
                case "XMSSMT":
                    return org.bouncycastle.pqc.jcajce.spec.XMSSMTParameterSpec.XMSSMT_SHA2_20d2_256;
                case "LMS":
                case "HSS":
                    return new org.bouncycastle.pqc.jcajce.spec.LMSKeyGenParameterSpec(
                            org.bouncycastle.pqc.crypto.lms.LMSigParameters.lms_sha256_n32_h10,
                            org.bouncycastle.pqc.crypto.lms.LMOtsParameters.sha256_n32_w4);
                case "MLKEM":
                case "KYBER":
                     
                    return null;
                case "NTRU":
                    return org.bouncycastle.pqc.jcajce.spec.NTRUParameterSpec.ntruhps2048509;
                case "NTRULPRime":
                    return org.bouncycastle.pqc.jcajce.spec.NTRULPRimeParameterSpec.ntrulpr653;
                case "SNTRUPrime":
                    return org.bouncycastle.pqc.jcajce.spec.SNTRUPrimeParameterSpec.sntrup761;
                case "SABER":
                    return org.bouncycastle.pqc.jcajce.spec.SABERParameterSpec.lightsaberkem128r3;
                case "FRODO":
                    return org.bouncycastle.pqc.jcajce.spec.FrodoParameterSpec.frodokem640aes;
                case "BIKE":
                    return org.bouncycastle.pqc.jcajce.spec.BIKEParameterSpec.bike128;
                case "HQC":
                    return org.bouncycastle.pqc.jcajce.spec.HQCParameterSpec.hqc128;
                case "CMCE":
                    return org.bouncycastle.pqc.jcajce.spec.CMCEParameterSpec.mceliece348864;
                default:
                    return null;
            }
        } catch (Exception e) {
            LOG.warn("Failed to create default parameter spec for algorithm: {}", algorithm, e);
            return null;
        }
    }

    public static Object deserializeJavaObjectFromStream(InputStream is) throws ClassNotFoundException, IOException {
        if (is == null) {
            return null;
        }

        Object answer;
        ObjectInputStream ois = new ObjectInputStream(is);
        try {
            answer = ois.readObject();
        } finally {
            IOHelper.close(ois);
        }

        return answer;
    }

    public InputStream getResourceAsStream(String name) {
        InputStream is = null;
        if (classLoader != null) {
            is = classLoader.getResourceAsStream(name);
        }
        if (is == null) {
            is = DefaultCamelCatalog.class.getClassLoader().getResourceAsStream(name);
        }
        return is;
    }

    protected String getNamespace(String uriExpression) {
        String namespacedName = uriExpression;
        if (uriExpression.contains("?")) {
            namespacedName = StringHelper.before(uriExpression, "?");
        }

        if (namespacedName.contains("/")) {
            return namespacedName.split("/", 2)[0];
        }

        return null;
    }

        protected void doProcess(String arg, LinkedList<String> remainingArgs) {
            if (remainingArgs.isEmpty()) {
                System.err.println("Expected fileName for ");
                showOptions();
                completed();
            } else {
                String parameter = remainingArgs.removeFirst();
                doProcess(arg, parameter, remainingArgs);
            }
        }

    protected void decode(ChannelHandlerContext ctx, AddressedEnvelope<Object, InetSocketAddress> msg, List<Object> out)
            throws Exception {
        if (msg.content() instanceof ByteBuf) {
            delegateDecoder.decode(ctx, (ByteBuf) msg.content(), out);
            byte[] content = (byte[]) out.remove(out.size() - 1);
            AddressedEnvelope<Object, InetSocketAddress> addressedEnvelop
                    = new DefaultAddressedEnvelope<>(content, msg.recipient(), msg.sender());
            out.add(addressedEnvelop);
        } else {
            LOG.debug("Ignoring message content as it is not an io.netty.buffer.ByteBuf instance.");
        }
    }

    public void process(Exchange exchange) throws Exception {
        Sqs2Operations operation = determineOperation(exchange);
        if (ObjectHelper.isEmpty(operation)) {
            processSingleMessage(exchange);
        } else {
            switch (operation) {
                case sendBatchMessage:
                    sendBatchMessage(getClient(), exchange);
                    break;
                case deleteMessage:
                    deleteMessage(getClient(), exchange);
                    break;
                case listQueues:
                    listQueues(getClient(), exchange);
                    break;
                case purgeQueue:
                    purgeQueue(getClient(), exchange);
                    break;
                case deleteQueue:
                    deleteQueue(getClient(), exchange);
                    break;
                default:
                    throw new IllegalArgumentException("Unsupported operation");
            }
        }
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        SolrConfiguration config = new SolrConfiguration();
        config.setSolrClient(this.getSolrClient());
        config.setHost(this.getHost());
        config.setPort(this.getPort());
        config.setCollection(this.getDefaultCollection());
        config.setRequestTimeout(this.getRequestTimeout());
        config.setConnectionTimeout(this.getConnectionTimeout());
        config.setEnableSSL(this.isEnableSSL());
        config.setUsername(this.getUsername());
        config.setPassword(this.getPassword());
        config.configure(uri);

        Endpoint endpoint = new SolrEndpoint(uri, this, config);
        setProperties(endpoint, parameters);

         
         
        if (config.getCollection() == null && config.getSolrClient() != null) {
            config.setCollection(config.getSolrClient().getDefaultCollection());
        }

        return endpoint;
    }

    protected boolean matchSecret(String name) {
        Set<String> set = new HashSet<>();
        if (configmaps != null) {
            Collections.addAll(set, configmaps.split(","));
        }

        for (String part : set) {
            boolean result = name.contains(part) || PatternHelper.matchPattern(name, part);
            LOG.trace("Matching configmap id: {}={} -> {}", name, part, result);
            if (result) {
                return true;
            }
        }

        return false;
    }

    private void handleNotFound(
            ConfigurationPropertiesValidationResult result, String value, String longKey, List<String> enums) {
        result.addInvalidEnum(longKey, value);
        result.addInvalidEnumChoices(longKey, enums.toArray(new String[0]));
        if (suggestionStrategy != null) {
            Set<String> names = new LinkedHashSet<>(enums);
            String[] suggestions = suggestionStrategy.suggestEndpointOptions(names, value);
            if (suggestions != null) {
                result.addInvalidEnumSuggestions(longKey, suggestions);
            }
        }
    }

    public NettyHttpConfiguration copy() {
        try {
             
            NettyHttpConfiguration answer = (NettyHttpConfiguration) clone();
             
            answer.setEncodersAsList(new ArrayList<>(getEncodersAsList()));
            answer.setDecodersAsList(new ArrayList<>(getDecodersAsList()));
            return answer;
        } catch (CloneNotSupportedException e) {
            throw new RuntimeCamelException(e);
        }
    }

    public void setSigPolicyIdDocumentationReferences(List<String> sigPolicyIdDocumentationReferences) {
        if (sigPolicyIdDocumentationReferences == null) {
            throw new IllegalArgumentException("Parameter 'sigPolicyIdDocumentationReferences' is null");
        }
        for (String ref : sigPolicyIdDocumentationReferences) {
            if (ref == null || ref.isEmpty()) {
                throw new IllegalArgumentException(
                        "At least one documentation reference of the signature policy is null or empty");
            }
        }
        this.sigPolicyIdDocumentationReferences = sigPolicyIdDocumentationReferences;
    }

    public void process(Exchange exchange) {
        if (exchange.getIn().getBody() instanceof int[]) {
            int[] seed = exchange.getIn().getBody(int[].class);
            Image[] result = predict(exchange, seed);
            exchange.getIn().setBody(result);
        } else {
            throw new RuntimeCamelException("Data type is not supported. Body should be int[]");
        }
    }

    private void updatePids(Map<Long, Pid> rows) {
        List<Long> pids = findPids(name);
        ProcessHandle.allProcesses()
                .filter(ph -> pids.contains(ph.pid()))
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                    if (root != null) {
                        Pid row = new Pid();
                        row.pid = Long.toString(ph.pid());
                        JsonObject context = (JsonObject) root.get("context");
                        if (context == null) {
                            return;
                        }
                        row.name = context.getString("name");
                        if ("CamelJBang".equals(row.name)) {
                            row.name = ProcessHelper.extractName(root, ph);
                        }
                        int len = row.name.length();
                        if (len < NAME_MIN_WIDTH) {
                            len = NAME_MIN_WIDTH;
                        }
                        if (len > NAME_MAX_WIDTH) {
                            len = NAME_MAX_WIDTH;
                        }
                        if (len > nameMaxWidth) {
                            nameMaxWidth = len;
                        }
                        if (!rows.containsKey(ph.pid())) {
                            rows.put(ph.pid(), row);
                        }
                    }
                });

         
        Set<Long> remove = new HashSet<>();
        for (long pid : rows.keySet()) {
            if (!pids.contains(pid)) {
                remove.add(pid);
            }
        }
        for (long pid : remove) {
            rows.remove(pid);
        }
    }

    protected void openCircuit(Route route) {
        try {
            lock.lock();
            suspendOrStopConsumer(route.getConsumer());
            state.set(STATE_OPEN);
            openedAt = System.currentTimeMillis();
            this.addHalfOpenTimer(route);
            logState();
        } catch (Exception e) {
            handleException(e);
        } finally {
            lock.unlock();
        }
    }

    private void getIngestionJob(BedrockAgentClient bedrockAgentClient, Exchange exchange)
            throws InvalidPayloadException {
        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getMessage().getMandatoryBody();
            if (payload instanceof GetIngestionJobRequest) {
                GetIngestionJobResponse result;
                try {
                    result = bedrockAgentClient.getIngestionJob((GetIngestionJobRequest) payload);
                } catch (AwsServiceException ase) {
                    LOG.trace("Get Ingestion Job command returned the error code {}", ase.awsErrorDetails().errorCode());
                    throw ase;
                }
                Message message = getMessageForResponse(exchange);
                prepareGetIngestionJobResponse(result, message);
            }
        } else {
            String knowledgeBaseId;
            String dataSourceId;
            String ingestionJobId;
            GetIngestionJobRequest.Builder builder = GetIngestionJobRequest.builder();
            if (ObjectHelper.isEmpty(getConfiguration().getKnowledgeBaseId())) {
                if (ObjectHelper.isNotEmpty(exchange.getMessage().getHeader(BedrockAgentConstants.KNOWLEDGE_BASE_ID))) {
                    knowledgeBaseId = exchange.getMessage().getHeader(BedrockAgentConstants.KNOWLEDGE_BASE_ID, String.class);
                } else {
                    throw new IllegalArgumentException("KnowledgeBaseId must be specified");
                }
            } else {
                knowledgeBaseId = getConfiguration().getKnowledgeBaseId();
            }
            if (ObjectHelper.isEmpty(getConfiguration().getDataSourceId())) {
                if (ObjectHelper.isNotEmpty(exchange.getMessage().getHeader(BedrockAgentConstants.DATASOURCE_ID))) {
                    dataSourceId = exchange.getMessage().getHeader(BedrockAgentConstants.DATASOURCE_ID, String.class);
                } else {
                    throw new IllegalArgumentException("DataSourceId must be specified");
                }
            } else {
                dataSourceId = getConfiguration().getDataSourceId();
            }
            if (ObjectHelper.isEmpty(getConfiguration().getIngestionJobId())) {
                if (ObjectHelper.isNotEmpty(exchange.getMessage().getHeader(BedrockAgentConstants.INGESTION_JOB_ID))) {
                    ingestionJobId = exchange.getMessage().getHeader(BedrockAgentConstants.INGESTION_JOB_ID, String.class);
                } else {
                    throw new IllegalArgumentException("IngestionJobId must be specified");
                }
            } else {
                ingestionJobId = getConfiguration().getIngestionJobId();
            }
            builder.knowledgeBaseId(knowledgeBaseId);
            builder.dataSourceId(dataSourceId);
            builder.ingestionJobId(ingestionJobId);
            GetIngestionJobResponse output = bedrockAgentClient.getIngestionJob(builder.build());
            Message message = getMessageForResponse(exchange);
            prepareGetIngestionJobResponse(output, message);
        }
    }

    public void deleteJob(String jobId, Map<String, List<String>> headers, ResponseCallback callback) {
        final Request request = getRequest(HttpMethod.DELETE, jobUrl(jobId), headers);
        doHttpRequest(request, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                callback.onResponse(headers, ex);
            }
        });
    }

    private boolean accept(String name) {
        if (stubPattern == null) {
            return true;
        }

        boolean stubbed = false;
        for (String n : stubPattern.split(",")) {
            if (n.startsWith("dataformat:")) {
                stubbed |= PatternHelper.matchPattern(name, n.substring(11));
            }
        }
        return !stubbed;
    }

    public Map<String, String> getServiceMetadata() {
        HashMap<String, String> metadata = new HashMap<>();
        if (configuration.getQueueArn() != null) {
            metadata.put("queueArn", configuration.getQueueArn());
        }
        if (configuration.getTopicArn() != null) {
            metadata.put("topicArn", configuration.getTopicArn());
        }
        return metadata;
    }

        public AnnotationBuilder withDefaultValue(JsonNode node) {
            if (node == null) {
                return this;
            }
            if (node.isMissingNode()) {
                return this;
            }
            if (!node.isTextual() && !node.isNumber() && !node.isBoolean()) {
                return this;
            }

            return withDefaultValue(node.asText());
        }

    public static Predicate isInstanceOf(final Expression expression, final Class<?> type) {
        notNull(expression, "expression");
        notNull(type, "type");

        return new Predicate() {
            public boolean matches(Exchange exchange) {
                Object value = expression.evaluate(exchange, Object.class);
                return type.isInstance(value);
            }

            @Override
            public void init(CamelContext camelContext) {
                expression.init(camelContext);
            }

            @Override
            public String toString() {
                return expression + " instanceof " + type.getCanonicalName();
            }
        };
    }

    private void processGetQueryJob(Exchange exchange, AsyncCallback callback)
            throws SalesforceException {
        QueryJob job = exchange.getIn().getBody(QueryJob.class);
        String jobId;
        if (job != null) {
            jobId = job.getId();
        } else {
            jobId = getParameter(JOB_ID, exchange, USE_BODY, NOT_OPTIONAL);
        }
        bulkClient.getQueryJob(jobId, determineHeaders(exchange),
                new BulkApiV2Client.QueryJobResponseCallback() {
                    @Override
                    public void onResponse(QueryJob job, Map<String, String> headers, SalesforceException ex) {
                        processResponse(exchange, job, headers, ex, callback);
                    }
                });
    }

    private Object decodeWithAsymmetricKey(Exchange exchange, Document encodedDocument) throws Exception {

        if (keyStore == null && null != keyOrTrustStoreParameters) {
            keyStore = keyOrTrustStoreParameters.createKeyStore();
            keyStorePassword = keyOrTrustStoreParameters.getPassword();
        }

        if (this.keyStore == null) {
            throw new IllegalStateException("A key store must be defined for asymmetric key decryption.");
        }

        PrivateKey keyEncryptionKey = getPrivateKey(this.keyStore, this.recipientKeyAlias,
                this.keyPassword != null ? this.keyPassword : this.keyStorePassword);
        Object ret = null;
        try {
            ret = decode(exchange, encodedDocument, keyEncryptionKey, true);
        } catch (org.apache.xml.security.encryption.XMLEncryptionException ex) {
            if (ex.getMessage().equals("encryption.nokey")) {
                 
                ret = decode(exchange, encodedDocument, keyEncryptionKey, false);
            } else {
                throw ex;
            }
        }

         
        try {
            keyEncryptionKey.destroy();
        } catch (javax.security.auth.DestroyFailedException ex) {
            LOG.debug("Error destroying key: {}", ex.getMessage());
        }

        return ret;
    }

    public DynamicRouterEndpoint(final String uri, final DynamicRouterComponent component,
                                 final DynamicRouterConfiguration configuration,
                                 final DynamicRouterFilterService filterService) {
        super(uri, component);
        this.processorFactorySupplier = PROCESSOR_FACTORY_SUPPLIER;
        this.producerFactorySupplier = PRODUCER_FACTORY_SUPPLIER;
        this.recipientListSupplier = RECIPIENT_LIST_SUPPLIER;
        this.channel = configuration.getChannel();
        this.configuration = configuration;
        this.filterService = filterService;
        LOG.debug("Created Dynamic Router Control Channel endpoint URI: {}", uri);
    }

    private List<JsonObject> enrichSourceCode(String routeId, String location, int lines) {
        Route route = getCamelContext().getRoute(routeId);
        if (route == null) {
            return null;
        }
        Resource resource = route.getSourceResource();
        if (resource == null) {
            return null;
        }

        List<JsonObject> code = new ArrayList<>();

        location = StringHelper.afterLast(location, ":");
        int line = 0;
        try {
            if (location != null) {
                line = Integer.parseInt(location);
            }
            LineNumberReader reader = new LineNumberReader(resource.getReader());
            for (int i = 1; i <= line + lines; i++) {
                String t = reader.readLine();
                if (t != null) {
                    int low = line - lines + 2;  
                    int high = line + lines + 1 + 2;
                    if (i >= low && i <= high) {
                        JsonObject c = new JsonObject();
                        c.put("line", i);
                        if (line == i) {
                            c.put("match", true);
                        }
                        c.put("code", Jsoner.escape(t));
                        code.add(c);
                    }
                }
            }
            IOHelper.close(reader);
        } catch (Exception e) {
             
        }

        return code;
    }

        protected boolean setProperty(MarshalDefinition target, String propertyKey,
                String propertyName, Node node) {
            propertyKey = org.apache.camel.util.StringHelper.dashToCamelCase(propertyKey);
            switch(propertyKey) {
                case "dataFormatType": {
                    MappingNode val = asMappingNode(node);
                    setProperties(target, val);
                    break;
                }
                case "asn1": {
                    org.apache.camel.model.dataformat.ASN1DataFormat val = asType(node, org.apache.camel.model.dataformat.ASN1DataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "avro": {
                    org.apache.camel.model.dataformat.AvroDataFormat val = asType(node, org.apache.camel.model.dataformat.AvroDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "barcode": {
                    org.apache.camel.model.dataformat.BarcodeDataFormat val = asType(node, org.apache.camel.model.dataformat.BarcodeDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "base64": {
                    org.apache.camel.model.dataformat.Base64DataFormat val = asType(node, org.apache.camel.model.dataformat.Base64DataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "beanio": {
                    org.apache.camel.model.dataformat.BeanioDataFormat val = asType(node, org.apache.camel.model.dataformat.BeanioDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "bindy": {
                    org.apache.camel.model.dataformat.BindyDataFormat val = asType(node, org.apache.camel.model.dataformat.BindyDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "cbor": {
                    org.apache.camel.model.dataformat.CBORDataFormat val = asType(node, org.apache.camel.model.dataformat.CBORDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "crypto": {
                    org.apache.camel.model.dataformat.CryptoDataFormat val = asType(node, org.apache.camel.model.dataformat.CryptoDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "csv": {
                    org.apache.camel.model.dataformat.CsvDataFormat val = asType(node, org.apache.camel.model.dataformat.CsvDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "custom": {
                    org.apache.camel.model.dataformat.CustomDataFormat val = asType(node, org.apache.camel.model.dataformat.CustomDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "dfdl": {
                    org.apache.camel.model.dataformat.DfdlDataFormat val = asType(node, org.apache.camel.model.dataformat.DfdlDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "fhirJson": {
                    org.apache.camel.model.dataformat.FhirJsonDataFormat val = asType(node, org.apache.camel.model.dataformat.FhirJsonDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "fhirXml": {
                    org.apache.camel.model.dataformat.FhirXmlDataFormat val = asType(node, org.apache.camel.model.dataformat.FhirXmlDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "flatpack": {
                    org.apache.camel.model.dataformat.FlatpackDataFormat val = asType(node, org.apache.camel.model.dataformat.FlatpackDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "fory": {
                    org.apache.camel.model.dataformat.ForyDataFormat val = asType(node, org.apache.camel.model.dataformat.ForyDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "grok": {
                    org.apache.camel.model.dataformat.GrokDataFormat val = asType(node, org.apache.camel.model.dataformat.GrokDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "groovyXml": {
                    org.apache.camel.model.dataformat.GroovyXmlDataFormat val = asType(node, org.apache.camel.model.dataformat.GroovyXmlDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "gzipDeflater": {
                    org.apache.camel.model.dataformat.GzipDeflaterDataFormat val = asType(node, org.apache.camel.model.dataformat.GzipDeflaterDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "hl7": {
                    org.apache.camel.model.dataformat.HL7DataFormat val = asType(node, org.apache.camel.model.dataformat.HL7DataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "ical": {
                    org.apache.camel.model.dataformat.IcalDataFormat val = asType(node, org.apache.camel.model.dataformat.IcalDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "iso8583": {
                    org.apache.camel.model.dataformat.Iso8583DataFormat val = asType(node, org.apache.camel.model.dataformat.Iso8583DataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "jacksonXml": {
                    org.apache.camel.model.dataformat.JacksonXMLDataFormat val = asType(node, org.apache.camel.model.dataformat.JacksonXMLDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "jaxb": {
                    org.apache.camel.model.dataformat.JaxbDataFormat val = asType(node, org.apache.camel.model.dataformat.JaxbDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "json": {
                    org.apache.camel.model.dataformat.JsonDataFormat val = asType(node, org.apache.camel.model.dataformat.JsonDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "jsonApi": {
                    org.apache.camel.model.dataformat.JsonApiDataFormat val = asType(node, org.apache.camel.model.dataformat.JsonApiDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "lzf": {
                    org.apache.camel.model.dataformat.LZFDataFormat val = asType(node, org.apache.camel.model.dataformat.LZFDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "mimeMultipart": {
                    org.apache.camel.model.dataformat.MimeMultipartDataFormat val = asType(node, org.apache.camel.model.dataformat.MimeMultipartDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "parquetAvro": {
                    org.apache.camel.model.dataformat.ParquetAvroDataFormat val = asType(node, org.apache.camel.model.dataformat.ParquetAvroDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "protobuf": {
                    org.apache.camel.model.dataformat.ProtobufDataFormat val = asType(node, org.apache.camel.model.dataformat.ProtobufDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "rss": {
                    org.apache.camel.model.dataformat.RssDataFormat val = asType(node, org.apache.camel.model.dataformat.RssDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "smooks": {
                    org.apache.camel.model.dataformat.SmooksDataFormat val = asType(node, org.apache.camel.model.dataformat.SmooksDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "soap": {
                    org.apache.camel.model.dataformat.SoapDataFormat val = asType(node, org.apache.camel.model.dataformat.SoapDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "swiftMt": {
                    org.apache.camel.model.dataformat.SwiftMtDataFormat val = asType(node, org.apache.camel.model.dataformat.SwiftMtDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "swiftMx": {
                    org.apache.camel.model.dataformat.SwiftMxDataFormat val = asType(node, org.apache.camel.model.dataformat.SwiftMxDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "syslog": {
                    org.apache.camel.model.dataformat.SyslogDataFormat val = asType(node, org.apache.camel.model.dataformat.SyslogDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "tarFile": {
                    org.apache.camel.model.dataformat.TarFileDataFormat val = asType(node, org.apache.camel.model.dataformat.TarFileDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "thrift": {
                    org.apache.camel.model.dataformat.ThriftDataFormat val = asType(node, org.apache.camel.model.dataformat.ThriftDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "univocityCsv": {
                    org.apache.camel.model.dataformat.UniVocityCsvDataFormat val = asType(node, org.apache.camel.model.dataformat.UniVocityCsvDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "univocityFixed": {
                    org.apache.camel.model.dataformat.UniVocityFixedDataFormat val = asType(node, org.apache.camel.model.dataformat.UniVocityFixedDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "univocityTsv": {
                    org.apache.camel.model.dataformat.UniVocityTsvDataFormat val = asType(node, org.apache.camel.model.dataformat.UniVocityTsvDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "xmlSecurity": {
                    org.apache.camel.model.dataformat.XMLSecurityDataFormat val = asType(node, org.apache.camel.model.dataformat.XMLSecurityDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "pgp": {
                    org.apache.camel.model.dataformat.PGPDataFormat val = asType(node, org.apache.camel.model.dataformat.PGPDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "yaml": {
                    org.apache.camel.model.dataformat.YAMLDataFormat val = asType(node, org.apache.camel.model.dataformat.YAMLDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "zipDeflater": {
                    org.apache.camel.model.dataformat.ZipDeflaterDataFormat val = asType(node, org.apache.camel.model.dataformat.ZipDeflaterDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "zipFile": {
                    org.apache.camel.model.dataformat.ZipFileDataFormat val = asType(node, org.apache.camel.model.dataformat.ZipFileDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "disabled": {
                    String val = asText(node);
                    target.setDisabled(val);
                    break;
                }
                case "variableReceive": {
                    String val = asText(node);
                    target.setVariableReceive(val);
                    break;
                }
                case "variableSend": {
                    String val = asText(node);
                    target.setVariableSend(val);
                    break;
                }
                case "id": {
                    String val = asText(node);
                    target.setId(val);
                    break;
                }
                case "description": {
                    String val = asText(node);
                    target.setDescription(val);
                    break;
                }
                case "note": {
                    String val = asText(node);
                    target.setNote(val);
                    break;
                }
                default: {
                    return false;
                }
            }
            return true;
        }

    protected void doDelete(Exchange exchange, String namespaceName) {
        String customResourceName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_CRD_INSTANCE_NAME, String.class);
        if (ObjectHelper.isEmpty(customResourceName)) {
            LOG.error("Deleting a specific custom resource require specify a custom resource name");
            throw new IllegalArgumentException("Deleting a specific custom resource require specify a custom resource name");
        }

        try {
            List<StatusDetails> statusDetails
                    = getEndpoint().getKubernetesClient().genericKubernetesResources(getCRDContext(exchange.getIn()))
                            .inNamespace(namespaceName).withName(customResourceName).delete();

            boolean deleted = ObjectHelper.isNotEmpty(statusDetails);
            exchange.getMessage().setHeader(KubernetesConstants.KUBERNETES_DELETE_RESULT, deleted);
        } catch (KubernetesClientException e) {
            if (e.getCode() == 404) {
                LOG.info("Custom resource instance not found", e);
            } else {
                throw e;
            }
        }

    }

    List<Long> findPids(String name) {
        List<Long> pids = new ArrayList<>();

         
        if (name.matches("\\d+")) {
            return List.of(Long.parseLong(name));
        } else {
            if (name.endsWith("!")) {
                 
                name = name.substring(0, name.length() - 1);
            } else if (!name.endsWith("*")) {
                 
                name = name + "*";
            }
        }

        final long cur = ProcessHandle.current().pid();
        final String pattern = name;
        ProcessHandle.allProcesses()
                .filter(ph -> ph.pid() != cur)
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                     
                    if (root != null) {
                        String pName = ProcessHelper.extractName(root, ph);
                         
                        pName = FileUtil.onlyName(pName);
                        if (pName != null && !pName.isEmpty() && PatternHelper.matchPattern(pName, pattern)) {
                            pids.add(ph.pid());
                        } else {
                             
                            JsonObject context = (JsonObject) root.get("context");
                            if (context != null) {
                                pName = context.getString("name");
                                if ("CamelJBang".equals(pName)) {
                                    pName = null;
                                }
                                if (pName != null && !pName.isEmpty() && PatternHelper.matchPattern(pName, pattern)) {
                                    pids.add(ph.pid());
                                }
                            }
                        }
                    }
                });

        return pids;
    }

    private void processGetBatch(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {
        String jobId;
        BatchInfo batchBody = exchange.getIn().getBody(BatchInfo.class);
        String batchId;
        if (batchBody != null) {
            jobId = batchBody.getJobId();
            batchId = batchBody.getId();
        } else {
            jobId = getParameter(JOB_ID, exchange, IGNORE_BODY, NOT_OPTIONAL);
            batchId = getParameter(BATCH_ID, exchange, USE_BODY, NOT_OPTIONAL);
        }
        bulkClient.getBatch(jobId, batchId, determineHeaders(exchange), new BulkApiClient.BatchInfoResponseCallback() {
            @Override
            public void onResponse(BatchInfo batchInfo, Map<String, String> headers, SalesforceException ex) {
                processResponse(exchange, batchInfo, headers, ex, callback);
            }
        });
    }

    public <T> T convertTo(Class<?> from, Class<T> to, Exchange exchange, Object value) throws TypeConversionException {
        try {
            Object obj = doConvertTo(from, to, exchange, value);
            return (T) obj;
        } catch (TypeConversionException e) {
            throw e;
        } catch (Exception e) {
            throw new TypeConversionException(value, to, e);
        }
    }

    public Object sendBodyAndHeaders(
            Endpoint endpoint, ExchangePattern pattern, final Object body, final Map<String, Object> headers)
            throws CamelExecutionException {
        Exchange exchange = send(endpoint, pattern, createBodyAndHeaders(body, headers));
        Object result = extractResultBody(exchange, pattern);
        if (pattern == ExchangePattern.InOnly) {
             
            return null;
        } else {
            return result;
        }
    }

    private static GenericFileExclusiveReadLockStrategy<FileIdBothDirectoryInformation> getExclusiveReadLockStrategy(
            Map<String, Object> params) {
        GenericFileExclusiveReadLockStrategy<FileIdBothDirectoryInformation> strategy
                = (GenericFileExclusiveReadLockStrategy<FileIdBothDirectoryInformation>) params
                        .get("exclusiveReadLockStrategy");
        if (strategy != null) {
            return strategy;
        }

         
        String readLock = (String) params.get("readLock");
        if (ObjectHelper.isNotEmpty(readLock)) {
            if ("none".equals(readLock) || "false".equals(readLock)) {
                return null;
            } else if ("rename".equals(readLock)) {
                GenericFileRenameExclusiveReadLockStrategy<FileIdBothDirectoryInformation> readLockStrategy
                        = new GenericFileRenameExclusiveReadLockStrategy<>();
                StrategyUtil.setup(readLockStrategy, params);
                return readLockStrategy;
            } else if ("changed".equals(readLock)) {
                SmbChangedExclusiveReadLockStrategy readLockStrategy = new SmbChangedExclusiveReadLockStrategy();
                StrategyUtil.setup(readLockStrategy, params);
                return readLockStrategy;
            }
        }

        return null;
    }

    private void configureFifoAttributes(SendMessageBatchRequestEntry.Builder request, Exchange exchange) {
        if (getEndpoint().getConfiguration().isFifoQueue()) {
             
            MessageGroupIdStrategy messageGroupIdStrategy = getEndpoint().getConfiguration().getMessageGroupIdStrategy();
            String messageGroupId = messageGroupIdStrategy.getMessageGroupId(exchange);
            request.messageGroupId(messageGroupId);

            MessageDeduplicationIdStrategy messageDeduplicationIdStrategy
                    = getEndpoint().getConfiguration().getMessageDeduplicationIdStrategy();
            String messageDeduplicationId = messageDeduplicationIdStrategy.getMessageDeduplicationId(exchange);
            request.messageDeduplicationId(messageDeduplicationId);

        }
    }

    public Exchange add(CamelContext camelContext, String key, Exchange exchange) {
        if (optimistic) {
            throw new UnsupportedOperationException();
        }
        LOG.trace("Adding an Exchange with ID {} for key {} in a thread-safe manner.", exchange.getExchangeId(), key);
        RLock lock = redisson.getLock("aggregationLock");
        try {
            lock.lock();
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(exchange, true, allowSerializedHeaders);
            DefaultExchangeHolder oldHolder = cache.put(key, newHolder);
            return unmarshallExchange(camelContext, oldHolder);
        } finally {
            LOG.trace("Added an Exchange with ID {} for key {} in a thread-safe manner.", exchange.getExchangeId(), key);
            lock.unlock();
        }
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        boolean cache = getAndRemoveParameter(parameters, "contentCache", Boolean.class, contentCache);

        JsltEndpoint answer = new JsltEndpoint(uri, this, remaining);
        answer.setContentCache(cache);
        answer.setAllowTemplateFromHeader(allowTemplateFromHeader);
        setProperties(answer, parameters);

         
        if (ResourceHelper.isHttpUri(remaining)) {
            remaining = ResourceHelper.appendParameters(remaining, parameters);
            answer.setResourceUri(remaining);
        }

        return answer;
    }

    protected KeyManagersParameters createInstance() throws Exception {
        KeyManagersParameters newInstance = new KeyManagersParameters();

        newInstance.setAlgorithm(algorithm);
        newInstance.setKeyPassword(keyPassword);
        if (getKeyStore() != null) {
            getKeyStore().setCamelContext(getCamelContext());
            newInstance.setKeyStore(getKeyStore().getObject());
        }
        newInstance.setProvider(provider);
        newInstance.setCamelContext(getCamelContext());

        return newInstance;
    }

    public int forceDiscardingOfGroup(String key) {
         
        int total = 0;

        lock.lock();
        try {
            Exchange exchange = aggregationRepository.get(camelContext, key);
            if (exchange != null) {
                total = 1;
                LOG.trace("Force discarded triggered for correlation key: {}", key);
                 
                onCompletion(key, exchange, exchange, false, true);
            }
        } finally {
            lock.unlock();
        }
        LOG.trace("Completed force discarded of group {}", key);

        if (total > 0) {
            LOG.debug("Forcing discarding of group {} with {} exchanges", key, total);
        }
        return total;
    }

    private User messageToUser(Message message) {
        User project = message.getBody(User.class);

        if (project == null) {
            Map headers = message.getHeaders();
            UserBuilder builder = Builders.user();

            StringHelper.notEmpty(message.getHeader(OpenstackConstants.NAME, String.class), "Name");
            builder.name(message.getHeader(OpenstackConstants.NAME, String.class));

            if (headers.containsKey(KeystoneConstants.DOMAIN_ID)) {
                builder.domainId(message.getHeader(KeystoneConstants.DOMAIN_ID, String.class));
            }

            if (headers.containsKey(KeystoneConstants.DESCRIPTION)) {
                builder.description(message.getHeader(KeystoneConstants.DESCRIPTION, String.class));
            }

            if (headers.containsKey(KeystoneConstants.PASSWORD)) {
                builder.password(message.getHeader(KeystoneConstants.PASSWORD, String.class));
            }

            if (headers.containsKey(KeystoneConstants.EMAIL)) {
                builder.email(message.getHeader(KeystoneConstants.EMAIL, String.class));
            }

            project = builder.build();
        }
        return project;
    }

    public ByteBuffer marshallExchange(Exchange exchange, boolean allowSerializedHeaders)
            throws IOException {
         
        DefaultExchangeHolder pe = DefaultExchangeHolder.marshal(exchange, false, allowSerializedHeaders);
         
         
        DefaultExchangeHolder.addProperty(pe, Exchange.AGGREGATED_SIZE,
                exchange.getProperty(ExchangePropertyKey.AGGREGATED_SIZE, Integer.class));
        DefaultExchangeHolder.addProperty(pe, Exchange.AGGREGATED_TIMEOUT,
                exchange.getProperty(ExchangePropertyKey.AGGREGATED_TIMEOUT, Long.class));
         
        DefaultExchangeHolder.addProperty(pe, Exchange.AGGREGATED_COMPLETED_BY,
                exchange.getProperty(ExchangePropertyKey.AGGREGATED_COMPLETED_BY, String.class));
         
        DefaultExchangeHolder.addProperty(pe, Exchange.AGGREGATED_CORRELATION_KEY,
                exchange.getProperty(ExchangePropertyKey.AGGREGATED_CORRELATION_KEY, String.class));
         
        DefaultExchangeHolder.addProperty(pe, Exchange.AGGREGATED_COLLECTION_GUARD,
                exchange.getProperty(Exchange.AGGREGATED_COLLECTION_GUARD, String.class));
         
        if (exchange.getFromEndpoint() != null) {
            DefaultExchangeHolder.addProperty(pe, "CamelAggregatedFromEndpoint", exchange.getFromEndpoint().getEndpointUri());
        }
        return ByteBuffer.wrap(serialize(pe));
    }

    protected Integer doDumpCall() throws Exception {
         
        tableHelper = new MessageTableHelper();
        tableHelper.setPretty(pretty);
        tableHelper.setLoggingColor(loggingColor);

        Map<Long, Pid> pids = new LinkedHashMap<>();

         
        updatePids(pids);
        if (!pids.isEmpty()) {
             
            if (find != null) {
                findAnsi = Ansi.ansi().fg(Ansi.Color.BLACK).bg(Ansi.Color.YELLOW).a("$0").reset().toString();
                for (int i = 0; i < find.length; i++) {
                    String f = find[i];
                    f = Pattern.quote(f);
                    find[i] = f;
                }
            }
            if (grep != null) {
                findAnsi = Ansi.ansi().fg(Ansi.Color.BLACK).bg(Ansi.Color.YELLOW).a("$0").reset().toString();
                for (int i = 0; i < grep.length; i++) {
                    String f = grep[i];
                    f = Pattern.quote(f);
                    grep[i] = f;
                }
            }
            Date limit = null;
            if (since != null) {
                long millis;
                if (StringHelper.isDigit(since)) {
                     
                    millis = TimePatternConverter.toMilliSeconds(since) * 1000;
                } else {
                    millis = TimePatternConverter.toMilliSeconds(since);
                }
                limit = new Date(System.currentTimeMillis() - millis);
            }
             
            if (tail != 0) {
                tailReceiveFiles(pids, tail);
                dumpReceiveFiles(pids, tail, limit);
            }
        }

        if (follow) {
            boolean waitMessage = true;
            final AtomicBoolean running = new AtomicBoolean(true);
            Thread t = new Thread(() -> {
                waitUserTask = new CommandHelper.ReadConsoleTask(() -> running.set(false));
                waitUserTask.run();
            }, "WaitForUser");
            t.start();
            boolean more = true;
            boolean init = true;
            StopWatch watch = new StopWatch();
            do {
                if (pids.isEmpty()) {
                    if (waitMessage) {
                        if (!"json".equals(output)) {
                            printer().println("Waiting for messages ...");
                        }
                        waitMessage = false;
                    }
                    Thread.sleep(500);
                    updatePids(pids);
                } else {
                    waitMessage = true;
                    if (watch.taken() > 500) {
                         
                        updatePids(pids);
                        watch.restart();
                    }
                    int lines = readReceiveFiles(pids);
                    if (lines > 0) {
                        more = dumpReceiveFiles(pids, 0, null);
                        init = false;
                    } else if (lines == 0) {
                        if (init) {
                            if (!"json".equals(output)) {
                                printer().println("Waiting for messages ...");
                            }
                            init = false;
                        }
                        Thread.sleep(100);
                    } else {
                        break;
                    }
                }
            } while (more && running.get());
        }

        return 0;
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulAgentProducer target = (org.apache.camel.component.consul.endpoint.ConsulAgentProducer) obj;
        switch (key) {
        case "agent":
        case "AGENT": return target.invokeAgent(exchange.getMessage());
        case "checks":
        case "CHECKS": return target.invokeChecks(exchange.getMessage());
        case "deregister":
        case "DEREGISTER": target.invokeDeregister(exchange.getMessage()); return null;
        case "members":
        case "MEMBERS": return target.invokeMembers(exchange.getMessage());
        case "register":
        case "REGISTER": target.invokeRegister(exchange.getMessage()); return null;
        case "services":
        case "SERVICES": return target.invokeServices(exchange.getMessage());
        default: return null;
        }
    }

    protected JsonObject doCallJson(Map<String, Object> options) {
        JsonObject root = new JsonObject();

        List<ResilienceProcessor> cbs = new ArrayList<>();
        for (Route route : getCamelContext().getRoutes()) {
            List<Processor> list = route.filter("*");
            for (Processor p : list) {
                if (p instanceof ResilienceProcessor) {
                    cbs.add((ResilienceProcessor) p);
                }
            }
        }
         
        cbs.sort(Comparator.comparing(ResilienceProcessor::getId));

        final List<JsonObject> list = new ArrayList<>();
        for (ResilienceProcessor cb : cbs) {
            JsonObject jo = new JsonObject();
            jo.put("id", cb.getId());
            jo.put("routeId", cb.getRouteId());
            jo.put("state", cb.getCircuitBreakerState());
            jo.put("bufferedCalls", cb.getNumberOfBufferedCalls());
            jo.put("successfulCalls", cb.getNumberOfSuccessfulCalls());
            jo.put("failedCalls", cb.getNumberOfFailedCalls());
            jo.put("notPermittedCalls", cb.getNumberOfNotPermittedCalls());
            jo.put("failureRate", cb.getFailureRate());
            list.add(jo);
        }
        root.put("circuitBreakers", list);

        return root;
    }

        public void run() {
            LOG.info("Listening on port {}", this.serverSocket.getLocalPort());
            while (!Thread.interrupted()) {
                try {
                    Socket inSocket = this.serverSocket.accept();
                     
                    Thread t = new RequestHandlerThread(this.httpService, inSocket);
                    t.setDaemon(true);
                    t.start();
                } catch (final InterruptedIOException | SocketException ex) {
                     
                    break;
                } catch (final IOException e) {
                    LOG.error("I/O error initialising connection thread: {}", e.getMessage());
                    break;
                }
            }
        }

    private void listIngestionJobs(BedrockAgentClient bedrockAgentClient, Exchange exchange)
            throws InvalidPayloadException {
        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getMessage().getMandatoryBody();
            if (payload instanceof ListIngestionJobsRequest) {
                ListIngestionJobsResponse result;
                try {
                    result = bedrockAgentClient.listIngestionJobs((ListIngestionJobsRequest) payload);
                } catch (AwsServiceException ase) {
                    LOG.trace("Start Ingestion Job command returned the error code {}", ase.awsErrorDetails().errorCode());
                    throw ase;
                }
                Message message = getMessageForResponse(exchange);
                prepareListIngestionJobsResponse(result, message);
            }
        } else {
            String knowledgeBaseId;
            String dataSourceId;
            ListIngestionJobsRequest.Builder builder = ListIngestionJobsRequest.builder();
            if (ObjectHelper.isEmpty(getConfiguration().getKnowledgeBaseId())) {
                if (ObjectHelper.isNotEmpty(exchange.getMessage().getHeader(BedrockAgentConstants.KNOWLEDGE_BASE_ID))) {
                    knowledgeBaseId = exchange.getIn().getHeader(BedrockAgentConstants.KNOWLEDGE_BASE_ID, String.class);
                } else {
                    throw new IllegalArgumentException("KnowledgeBaseId must be specified");
                }
            } else {
                knowledgeBaseId = getConfiguration().getKnowledgeBaseId();
            }
            if (ObjectHelper.isEmpty(getConfiguration().getDataSourceId())) {
                if (ObjectHelper.isNotEmpty(exchange.getMessage().getHeader(BedrockAgentConstants.DATASOURCE_ID))) {
                    dataSourceId = exchange.getIn().getHeader(BedrockAgentConstants.DATASOURCE_ID, String.class);
                } else {
                    throw new IllegalArgumentException("DataSourceId must be specified");
                }
            } else {
                dataSourceId = getConfiguration().getDataSourceId();
            }
            builder.knowledgeBaseId(knowledgeBaseId);
            builder.dataSourceId(dataSourceId);
            ListIngestionJobsResponse output = bedrockAgentClient.listIngestionJobs(builder.build());
            Message message = getMessageForResponse(exchange);
            prepareListIngestionJobsResponse(output, message);
        }
    }

    private SmnClient initializeClient(ClientConfigurations clientConfigurations) {
        if (LOG.isDebugEnabled()) {
            LOG.debug("Initializing Smn client");
        }
        HttpConfig httpConfig
                = HttpConfig.getDefaultHttpConfig().withIgnoreSSLVerification(clientConfigurations.isIgnoreSslVerification());
        if (!StringUtils.isEmpty(clientConfigurations.getProxyHost())) {
            httpConfig.setProxyHost(clientConfigurations.getProxyHost());
            httpConfig.setProxyPort(clientConfigurations.getProxyPort());
            if (!StringUtils.isEmpty(clientConfigurations.getProxyUser())) {
                httpConfig.setProxyUsername(clientConfigurations.getProxyUser());
                httpConfig.setProxyPassword(clientConfigurations.getProxyPassword());
            }
        }

        BasicCredentials credentials = new BasicCredentials()
                .withAk(clientConfigurations.getAccessKey())
                .withSk(clientConfigurations.getSecretKey())
                .withProjectId(clientConfigurations.getProjectId());

        if (LOG.isDebugEnabled()) {
            LOG.debug("Building Smn client");
        }

         
        SmnClient smnClient = SmnClient.newBuilder()
                .withCredential(credentials)
                .withHttpConfig(httpConfig)
                .withEndpoint(clientConfigurations.getServiceEndpoint())
                .build();

        if (LOG.isDebugEnabled()) {
            LOG.debug("Successfully initialized Smn client");
        }
        return smnClient;
    }

    public static Object[] toArray(Object object) {
        if (object instanceof Collection) {
            return ((Collection<?>) object).toArray();
        } else {
            Object[] answer;
            if (object == null) {
                answer = new Object[0];
            } else {
                answer = new Object[1];
                answer[0] = object;
            }
            return answer;
        }
    }

private int jjMoveStringLiteralDfa3_0(long old0, long active0){
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_0(1, old0);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(2, active0);
      return 3;
   }
   switch(curChar)
   {
      case 32:
         if ((active0 & 0x4L) != 0L)
            return jjStopAtPos(3, 2);
         break;
      case 85:
         return jjMoveStringLiteralDfa4_0(active0, 0x8L);
      default :
         break;
   }
   return jjStartNfa_0(2, active0);
}

    private Collection<Consumer<byte[]>> createMultipleConsumers(final PulsarEndpoint pulsarEndpoint) {
        final Collection<Consumer<byte[]>> consumers = new LinkedList<>();
        final PulsarConfiguration configuration = pulsarEndpoint.getPulsarConfiguration();

        for (int i = 0; i < configuration.getNumberOfConsumers(); i++) {
            final String consumerName = configuration.getConsumerNamePrefix() + i;
            try {
                ConsumerBuilder<byte[]> builder
                        = CommonCreationStrategyImpl.getBuilder(consumerName, pulsarEndpoint, pulsarConsumer);

                consumers.add(builder.subscriptionType(SubscriptionType.Key_Shared).subscribe());
            } catch (PulsarClientException exception) {
                LOGGER.error("A PulsarClientException occurred when creating Consumer {}, {}", consumerName,
                        exception.getMessage(), exception);
            }
        }
        return consumers;
    }

    public Expression createExpression(String expression) {
        if (expression == null) {
            throw new IllegalArgumentException("expression must be specified");
        }
         
        String text = expression.replace("\n", "");
        text = text.trim();

        return compiledExpressions.computeIfAbsent(text, key -> {
            if (compilationSupport != null) {
                CSimpleExpression exp = compilationSupport.compileExpression(getCamelContext(), expression);
                if (exp != null) {
                    exp.init(getCamelContext());
                    return exp;
                }
            }
            throw new CSimpleException("Cannot find compiled csimple language for expression: " + expression, expression);
        });
    }

    private void bulkAssignRoleToUsers(Keycloak keycloakClient, Exchange exchange) {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

         
        RoleRepresentation role;
        try {
            role = keycloakClient.realm(realmName).roles().get(roleName).toRepresentation();
        } catch (Exception e) {
            throw new RuntimeException("Failed to find role: " + roleName, e);
        }

        List<String> userIds = exchange.getIn().getHeader(KeycloakConstants.USER_IDS, List.class);
        if (userIds == null || userIds.isEmpty()) {
             
            List<String> usernames = exchange.getIn().getHeader(KeycloakConstants.USERNAMES, List.class);
            if (usernames == null || usernames.isEmpty()) {
                 
                Object payload = exchange.getIn().getBody();
                if (payload instanceof List) {
                    userIds = CastUtils.cast((List<?>) payload);
                } else {
                    throw new IllegalArgumentException("User IDs or usernames must be provided via header or body");
                }
            } else {
                 
                userIds = new ArrayList<>();
                for (String username : usernames) {
                    List<UserRepresentation> foundUsers
                            = keycloakClient.realm(realmName).users().searchByUsername(username, true);
                    if (!foundUsers.isEmpty()) {
                        userIds.add(foundUsers.get(0).getId());
                    }
                }
            }
        }

        boolean continueOnError
                = exchange.getIn().getHeader(KeycloakConstants.CONTINUE_ON_ERROR, Boolean.FALSE, Boolean.class);
        List<Map<String, Object>> results = new ArrayList<>();
        int successCount = 0;
        int failureCount = 0;

        for (String userId : userIds) {
            Map<String, Object> result = new HashMap<>();
            result.put("userId", userId);
            try {
                keycloakClient.realm(realmName).users().get(userId).roles().realmLevel().add(List.of(role));
                result.put("status", "success");
                successCount++;
            } catch (Exception e) {
                result.put("status", "failed");
                result.put("error", e.getMessage());
                failureCount++;
                if (!continueOnError) {
                    throw new RuntimeException("Failed to assign role to user: " + userId, e);
                }
            }
            results.add(result);
        }

        Map<String, Object> summary = new HashMap<>();
        summary.put("total", userIds.size());
        summary.put("success", successCount);
        summary.put("failed", failureCount);
        summary.put("roleName", roleName);
        summary.put("results", results);

        Message message = getMessageForResponse(exchange);
        message.setBody(summary);
    }

    public void configureProperties(Map<String, Object> options) {
         
        Map<String, Object> query = new CaseInsensitiveMap();
        Map<String, Object> known = new CaseInsensitiveMap();
        options.forEach((k, v) -> {
            if (k.startsWith("$")) {
                query.put(k, v);
            } else {
                known.put(k, v);
            }
        });
        options.keySet().removeIf(known::containsKey);

         
        PropertyConfigurer configurer = getComponent().getEndpointPropertyConfigurer();
        if (configurer instanceof ExtendedPropertyConfigurerGetter) {
            ExtendedPropertyConfigurerGetter getter = (ExtendedPropertyConfigurerGetter) configurer;
            for (String name : getter.getAllOptions(this).keySet()) {
                if (known.containsKey(name)) {
                    Object value = known.get(name);
                    boolean hit = configurer.configure(getCamelContext(), this, name, value, true);
                    if (hit) {
                        known.remove(name);
                    }
                }
            }
        }
         
        configurer = PluginHelper.getConfigurerResolver(getCamelContext())
                .resolvePropertyConfigurer(configuration.getClass().getName(), getCamelContext());
        if (configurer != null) {
            PropertyBindingSupport.build()
                    .withConfigurer(configurer)
                    .withIgnoreCase(true)
                    .withTarget(configuration)
                    .withCamelContext(getCamelContext())
                    .withProperties(known)
                    .withRemoveParameters(true)
                    .bind();
        }
        super.configureProperties(known);
        if (!known.isEmpty()) {
             
            query.putAll(known);
        }
         
        options.keySet().removeIf(query::containsKey);
         
        parseQueryParams(query);
         
        options.putAll(query);
    }

    protected SubmitSm createSubmitSmTemplate(Exchange exchange) {
        Message in = exchange.getIn();
        SubmitSm submitSm = new SubmitSm();

        if (in.getHeaders().containsKey(SmppConstants.DATA_CODING)) {
            submitSm.setDataCoding(in.getHeader(SmppConstants.DATA_CODING, Byte.class));
        } else if (in.getHeaders().containsKey(SmppConstants.ALPHABET)) {
            submitSm.setDataCoding(in.getHeader(SmppConstants.ALPHABET, Byte.class));
        } else {
            submitSm.setDataCoding(config.getDataCoding());
        }

        if (in.getHeaders().containsKey(SmppConstants.DEST_ADDR)) {
            submitSm.setDestAddress(in.getHeader(SmppConstants.DEST_ADDR, String.class));
        } else {
            submitSm.setDestAddress(config.getDestAddr());
        }

        if (in.getHeaders().containsKey(SmppConstants.DEST_ADDR_TON)) {
            submitSm.setDestAddrTon(in.getHeader(SmppConstants.DEST_ADDR_TON, Byte.class));
        } else {
            submitSm.setDestAddrTon(config.getDestAddrTon());
        }

        if (in.getHeaders().containsKey(SmppConstants.DEST_ADDR_NPI)) {
            submitSm.setDestAddrNpi(in.getHeader(SmppConstants.DEST_ADDR_NPI, Byte.class));
        } else {
            submitSm.setDestAddrNpi(config.getDestAddrNpi());
        }

        if (in.getHeaders().containsKey(SmppConstants.SOURCE_ADDR)) {
            submitSm.setSourceAddr(in.getHeader(SmppConstants.SOURCE_ADDR, String.class));
        } else {
            submitSm.setSourceAddr(config.getSourceAddr());
        }

        if (in.getHeaders().containsKey(SmppConstants.SOURCE_ADDR_TON)) {
            submitSm.setSourceAddrTon(in.getHeader(SmppConstants.SOURCE_ADDR_TON, Byte.class));
        } else {
            submitSm.setSourceAddrTon(config.getSourceAddrTon());
        }

        if (in.getHeaders().containsKey(SmppConstants.SOURCE_ADDR_NPI)) {
            submitSm.setSourceAddrNpi(in.getHeader(SmppConstants.SOURCE_ADDR_NPI, Byte.class));
        } else {
            submitSm.setSourceAddrNpi(config.getSourceAddrNpi());
        }

        if (in.getHeaders().containsKey(SmppConstants.SERVICE_TYPE)) {
            submitSm.setServiceType(in.getHeader(SmppConstants.SERVICE_TYPE, String.class));
        } else {
            submitSm.setServiceType(config.getServiceType());
        }

        if (in.getHeaders().containsKey(SmppConstants.PROTOCOL_ID)) {
            submitSm.setProtocolId(in.getHeader(SmppConstants.PROTOCOL_ID, Byte.class));
        } else {
            submitSm.setProtocolId(config.getProtocolId());
        }

        if (in.getHeaders().containsKey(SmppConstants.PRIORITY_FLAG)) {
            submitSm.setPriorityFlag(in.getHeader(SmppConstants.PRIORITY_FLAG, Byte.class));
        } else {
            submitSm.setPriorityFlag(config.getPriorityFlag());
        }

        if (in.getHeaders().containsKey(SmppConstants.SCHEDULE_DELIVERY_TIME)) {
            submitSm.setScheduleDeliveryTime(
                    SmppUtils.formatTime(in.getHeader(SmppConstants.SCHEDULE_DELIVERY_TIME, Date.class)));
        }

        if (in.getHeaders().containsKey(SmppConstants.VALIDITY_PERIOD)) {
            Object validityPeriod = in.getHeader(SmppConstants.VALIDITY_PERIOD);
            if (validityPeriod instanceof String) {
                submitSm.setValidityPeriod((String) validityPeriod);
            } else if (validityPeriod instanceof Date) {
                submitSm.setValidityPeriod(SmppUtils.formatTime((Date) validityPeriod));
            }
        }

        if (in.getHeaders().containsKey(SmppConstants.REPLACE_IF_PRESENT_FLAG)) {
            submitSm.setReplaceIfPresent(in.getHeader(SmppConstants.REPLACE_IF_PRESENT_FLAG, Byte.class));
        } else {
            submitSm.setReplaceIfPresent(config.getReplaceIfPresentFlag());
        }

        submitSm.setEsmClass(new ESMClass().value());

        Map<java.lang.Short, Object> optinalParamater = in.getHeader(SmppConstants.OPTIONAL_PARAMETER, Map.class);
        if (optinalParamater != null) {
            List<OptionalParameter> optParams = createOptionalParametersByCode(optinalParamater);
            submitSm.setOptionalParameters(optParams.toArray(new OptionalParameter[0]));
        } else {
            Map<String, String> optinalParamaters = in.getHeader(SmppConstants.OPTIONAL_PARAMETERS, Map.class);
            if (optinalParamaters != null) {
                List<OptionalParameter> optParams = createOptionalParametersByName(optinalParamaters);
                submitSm.setOptionalParameters(optParams.toArray(new OptionalParameter[0]));
            } else {
                submitSm.setOptionalParameters();
            }
        }

        return submitSm;
    }

    protected Pattern createJsonMaskPattern(Set<String> keywords) {
        StringBuilder regex = createOneOfThemRegex(keywords);
        if (regex == null) {
            return null;
        }
        regex.insert(0, "\\\"(");
        regex.append(")\\\"(\\s*?):(\\s*?)\\\"([^\"]*)\\\"");

        if (LOG.isDebugEnabled()) {
            LOG.debug("JSon Pattern: {}", regex);
        }
        return Pattern.compile(regex.toString(), Pattern.CASE_INSENSITIVE);
    }

    private static void configureProxyAuthorizationPolicy(
            ServiceNowConfiguration configuration, WebClient client) {

        ProxyAuthorizationPolicy proxyPolicy = configuration.getProxyAuthorizationPolicy();
        if (proxyPolicy == null) {
            String username = configuration.getProxyUserName();
            String password = configuration.getProxyPassword();

            if (username != null && password != null) {
                proxyPolicy = new ProxyAuthorizationPolicy();
                proxyPolicy.setAuthorizationType("Basic");
                proxyPolicy.setUserName(username);
                proxyPolicy.setPassword(password);
            }
        }

        if (proxyPolicy != null) {
            WebClient.getConfig(client).getHttpConduit().setProxyAuthorization(proxyPolicy);
        }
    }

    protected void doStart() throws Exception {
        ObjectHelper.notNull(camelContext, "camelContext");
        ObjectHelper.notNull(configuration, "configuration");

        if (cache != null) {
            cacheManager = new JCacheManager<>(cache);
        } else {
            cacheManager = JCacheHelper.createManager(getCamelContext(), configuration);
            cache = cacheManager.getCache();
        }
    }

    private void userSelectedPropertiesMDC(Exchange exchange, boolean push) {
        for (String customProperty : getCustomProperties().split(",")) {
            if (exchange.getProperty(customProperty) != null) {
                if (push) {
                    MDC.put(customProperty, exchange.getProperty(customProperty, String.class));
                } else {
                    MDC.remove(customProperty);
                }
            }
        }
    }

    private void addConfigurationClass(Class<? extends CamelConfiguration>... configuration) {
        StringJoiner existing = new StringJoiner(",");
        if (configurationClasses != null && !configurationClasses.isEmpty()) {
            existing.add(configurationClasses);
        }
        if (configuration != null) {
            for (Class<? extends CamelConfiguration> clazz : configuration) {
                existing.add(clazz.getName());
            }
        }
        setConfigurationClasses(existing.toString());
    }

    private static void setAdditionalConfiguration(
            CamelContext camelContext, RestConfiguration config, DataFormat dataFormat, String prefix) {
        if (config.getDataFormatProperties() != null && !config.getDataFormatProperties().isEmpty()) {
             
             
            Map<String, Object> copy = new HashMap<>();

             
             
             
            for (Map.Entry<String, Object> entry : config.getDataFormatProperties().entrySet()) {
                String key = entry.getKey();
                String copyKey;
                boolean known = isKeyKnownPrefix(key);
                if (known) {
                     
                    copyKey = key.substring(prefix.length());
                } else {
                     
                    copyKey = key;
                }
                if (!known || key.startsWith(prefix)) {
                    copy.put(copyKey, entry.getValue());
                }
            }

            PropertyBindingSupport.build().bind(camelContext, dataFormat, copy);
        }
    }

    protected RouteTemplateDefinition createRouteTemplate() {
        RouteTemplateDefinition template = new RouteTemplateDefinition();
        ErrorHandlerFactory handler = getErrorHandlerFactory();
        if (handler != null) {
            template.getRoute().setErrorHandlerFactoryIfNull(handler);
        }
        if (resource != null) {
            template.setResource(resource);
        }
        return template;
    }

    public DynamicRouterEndpoint(final String uri, final DynamicRouterComponent component,
                                 final DynamicRouterConfiguration configuration,
                                 final DynamicRouterFilterService filterService) {
        super(uri, component);
        this.processorFactorySupplier = PROCESSOR_FACTORY_SUPPLIER;
        this.producerFactorySupplier = PRODUCER_FACTORY_SUPPLIER;
        this.recipientListSupplier = RECIPIENT_LIST_SUPPLIER;
        this.channel = configuration.getChannel();
        this.configuration = configuration;
        this.filterService = filterService;
        LOG.debug("Created Dynamic Router Control Channel endpoint URI: {}", uri);
    }

    public String dumpStepStatsAsXml(boolean fullStats) throws Exception {
        StringBuilder sb = new StringBuilder();
        sb.append("<camelContextStat")
                .append(String.format(" id=\"%s\" state=\"%s\" uptime=\"%s\"", getCamelId(), getState(), getUptimeMillis()));
         
        String stat = dumpStatsAsXml(fullStats);
        sb.append(" exchangesInflight=\"").append(getInflightExchanges()).append("\"");
        sb.append(" ").append(stat, 7, stat.length() - 2).append(">\n");

        MBeanServer server = getContext().getManagementStrategy().getManagementAgent().getMBeanServer();
        if (server != null) {
             
            String prefix = getContext().getManagementStrategy().getManagementAgent().getIncludeHostName() ? "*/" : "";
            ObjectName query = ObjectName
                    .getInstance(jmxDomain + ":context=" + prefix + getContext().getManagementName() + ",type=routes,*");
            Set<ObjectName> routes = server.queryNames(query, null);

            List<ManagedProcessorMBean> steps = new ArrayList<>();
             
            query = ObjectName
                    .getInstance(jmxDomain + ":context=" + prefix + getContext().getManagementName() + ",type=steps,*");
            Set<ObjectName> names = server.queryNames(query, null);
            for (ObjectName on : names) {
                ManagedStepMBean step
                        = context.getManagementStrategy().getManagementAgent().newProxyClient(on, ManagedStepMBean.class);
                steps.add(step);
            }
            steps.sort(new OrderProcessorMBeans());

             
            sb.append("  <routeStats>\n");
            for (ObjectName on : routes) {
                ManagedRouteMBean route
                        = context.getManagementStrategy().getManagementAgent().newProxyClient(on, ManagedRouteMBean.class);
                sb.append("    <routeStat")
                        .append(String.format(" id=\"%s\" state=\"%s\" uptime=\"%s\"", route.getRouteId(), route.getState(),
                                route.getUptimeMillis()));
                if (route.getRouteGroup() != null) {
                    sb.append(String.format(" group=\"%s\"", route.getRouteGroup()));
                }
                if (route.getSourceLocation() != null) {
                    sb.append(String.format(" sourceLocation=\"%s\"", route.getSourceLocation()));
                }

                 
                stat = route.dumpStatsAsXml(fullStats);
                sb.append(" exchangesInflight=\"").append(route.getExchangesInflight()).append("\"");
                sb.append(" ").append(stat, 7, stat.length() - 2).append(">\n");

                 
                sb.append("      <stepStats>\n");
                for (ManagedProcessorMBean step : steps) {
                     
                    if (route.getRouteId().equals(step.getRouteId())) {
                        int line = step.getSourceLineNumber() != null ? step.getSourceLineNumber() : -1;
                        sb.append("        <stepStat")
                                .append(String.format(
                                        " id=\"%s\" index=\"%s\" state=\"%s\" disabled=\"%s\" sourceLineNumber=\"%s\"",
                                        step.getProcessorId(), step.getIndex(), step.getState(), step.getDisabled(), line));
                         
                        stat = step.dumpStatsAsXml(fullStats);
                        sb.append(" exchangesInflight=\"").append(step.getExchangesInflight()).append("\"");
                        sb.append(" ").append(stat, 7, stat.length()).append("\n");
                    }
                    sb.append("      </stepStats>\n");
                }
                sb.append("    </stepStat>\n");
            }
            sb.append("  </routeStats>\n");
        }

        sb.append("</camelContextStat>");
        return sb.toString();
    }

    public static void configureEnvVars(Traits traitsSpec, String[] envVars) {
        if (envVars == null || envVars.length == 0) {
            return;
        }
        Environment environmentTrait = Optional.ofNullable(traitsSpec.getEnvironment()).orElseGet(Environment::new);
        if (environmentTrait.getVars() == null) {
            environmentTrait.setVars(new ArrayList<>());
        }
        environmentTrait.getVars().addAll(List.of(envVars));
        traitsSpec.setEnvironment(environmentTrait);
    }

    private GoogleMailApiCollection() {
        final Map<String, String> aliases = new HashMap<>();
        final Map<GoogleMailApiName, ApiMethodHelper<? extends ApiMethod>> apiHelpers = new EnumMap<>(GoogleMailApiName.class);
        final Map<Class<? extends ApiMethod>, GoogleMailApiName> apiMethods = new HashMap<>();

        List<String> nullableArgs;

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(GoogleMailApiName.THREADS, new ApiMethodHelper<>(GmailUsersThreadsApiMethod.class, aliases, nullableArgs));
        apiMethods.put(GmailUsersThreadsApiMethod.class, GoogleMailApiName.THREADS);

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(GoogleMailApiName.MESSAGES, new ApiMethodHelper<>(GmailUsersMessagesApiMethod.class, aliases, nullableArgs));
        apiMethods.put(GmailUsersMessagesApiMethod.class, GoogleMailApiName.MESSAGES);

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(GoogleMailApiName.ATTACHMENTS, new ApiMethodHelper<>(GmailUsersMessagesAttachmentsApiMethod.class, aliases, nullableArgs));
        apiMethods.put(GmailUsersMessagesAttachmentsApiMethod.class, GoogleMailApiName.ATTACHMENTS);

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(GoogleMailApiName.LABELS, new ApiMethodHelper<>(GmailUsersLabelsApiMethod.class, aliases, nullableArgs));
        apiMethods.put(GmailUsersLabelsApiMethod.class, GoogleMailApiName.LABELS);

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(GoogleMailApiName.HISTORY, new ApiMethodHelper<>(GmailUsersHistoryApiMethod.class, aliases, nullableArgs));
        apiMethods.put(GmailUsersHistoryApiMethod.class, GoogleMailApiName.HISTORY);

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(GoogleMailApiName.DRAFTS, new ApiMethodHelper<>(GmailUsersDraftsApiMethod.class, aliases, nullableArgs));
        apiMethods.put(GmailUsersDraftsApiMethod.class, GoogleMailApiName.DRAFTS);

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(GoogleMailApiName.USERS, new ApiMethodHelper<>(GmailUsersApiMethod.class, aliases, nullableArgs));
        apiMethods.put(GmailUsersApiMethod.class, GoogleMailApiName.USERS);

        setApiHelpers(apiHelpers);
        setApiMethods(apiMethods);
    }

    private static void invokeSynchronizationCallbacks(Route route, Exchange exchange, Logger log, List<Synchronization> copy) {
        for (Synchronization synchronization : copy) {
            final SynchronizationRouteAware routeSynchronization = synchronization.getRouteSynchronization();
            if (routeSynchronization != null) {
                try {
                    log.trace("Invoking synchronization.onBeforeRoute: {} with {}", synchronization, exchange);
                    routeSynchronization.onBeforeRoute(route, exchange);
                } catch (Exception e) {
                     
                    log.warn("Exception occurred during onBeforeRoute. This exception will be ignored.", e);
                }
            }
        }
    }

    private GoogleSheetsApiCollection() {
        final Map<String, String> aliases = new HashMap<>();
        final Map<GoogleSheetsApiName, ApiMethodHelper<? extends ApiMethod>> apiHelpers = new EnumMap<>(GoogleSheetsApiName.class);
        final Map<Class<? extends ApiMethod>, GoogleSheetsApiName> apiMethods = new HashMap<>();

        List<String> nullableArgs;

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(GoogleSheetsApiName.SPREADSHEETS, new ApiMethodHelper<>(SheetsSpreadsheetsApiMethod.class, aliases, nullableArgs));
        apiMethods.put(SheetsSpreadsheetsApiMethod.class, GoogleSheetsApiName.SPREADSHEETS);

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(GoogleSheetsApiName.DATA, new ApiMethodHelper<>(SheetsSpreadsheetsValuesApiMethod.class, aliases, nullableArgs));
        apiMethods.put(SheetsSpreadsheetsValuesApiMethod.class, GoogleSheetsApiName.DATA);

        setApiHelpers(apiHelpers);
        setApiMethods(apiMethods);
    }

    public ByteBuffer marshallExchange(Exchange exchange, boolean allowSerializedHeaders)
            throws IOException {
         
        DefaultExchangeHolder pe = DefaultExchangeHolder.marshal(exchange, false, allowSerializedHeaders);
         
         
        DefaultExchangeHolder.addProperty(pe, Exchange.AGGREGATED_SIZE,
                exchange.getProperty(ExchangePropertyKey.AGGREGATED_SIZE, Integer.class));
        DefaultExchangeHolder.addProperty(pe, Exchange.AGGREGATED_TIMEOUT,
                exchange.getProperty(ExchangePropertyKey.AGGREGATED_TIMEOUT, Long.class));
         
        DefaultExchangeHolder.addProperty(pe, Exchange.AGGREGATED_COMPLETED_BY,
                exchange.getProperty(ExchangePropertyKey.AGGREGATED_COMPLETED_BY, String.class));
         
        DefaultExchangeHolder.addProperty(pe, Exchange.AGGREGATED_CORRELATION_KEY,
                exchange.getProperty(ExchangePropertyKey.AGGREGATED_CORRELATION_KEY, String.class));
         
        DefaultExchangeHolder.addProperty(pe, Exchange.AGGREGATED_COLLECTION_GUARD,
                exchange.getProperty(Exchange.AGGREGATED_COLLECTION_GUARD, String.class));
         
        if (exchange.getFromEndpoint() != null) {
            DefaultExchangeHolder.addProperty(pe, "CamelAggregatedFromEndpoint", exchange.getFromEndpoint().getEndpointUri());
        }
        return ByteBuffer.wrap(serialize(pe));
    }

    private void setupCustomServices() {
        ModelJAXBContextFactory modelJAXBContextFactory = getBeanForType(ModelJAXBContextFactory.class);
        if (modelJAXBContextFactory != null) {
            LOG.info("Using custom ModelJAXBContextFactory: {}", modelJAXBContextFactory);
            getContext().getCamelContextExtension().addContextPlugin(ModelJAXBContextFactory.class, modelJAXBContextFactory);
        }
        ClassResolver classResolver = getBeanForType(ClassResolver.class);
        if (classResolver != null) {
            LOG.info("Using custom ClassResolver: {}", classResolver);
            getContext().setClassResolver(classResolver);
        }
        FactoryFinderResolver factoryFinderResolver = getBeanForType(FactoryFinderResolver.class);
        if (factoryFinderResolver != null) {
            LOG.info("Using custom FactoryFinderResolver: {}", factoryFinderResolver);
            getContext().getCamelContextExtension().addContextPlugin(FactoryFinderResolver.class, factoryFinderResolver);
        }
        ExecutorServiceManager executorServiceStrategy = getBeanForType(ExecutorServiceManager.class);
        if (executorServiceStrategy != null) {
            LOG.info("Using custom ExecutorServiceStrategy: {}", executorServiceStrategy);
            getContext().setExecutorServiceManager(executorServiceStrategy);
        }
        ThreadPoolFactory threadPoolFactory = getBeanForType(ThreadPoolFactory.class);
        if (threadPoolFactory != null) {
            LOG.info("Using custom ThreadPoolFactory: {}", threadPoolFactory);
            getContext().getExecutorServiceManager().setThreadPoolFactory(threadPoolFactory);
        }
        ProcessorFactory processorFactory = getBeanForType(ProcessorFactory.class);
        if (processorFactory != null) {
            LOG.info("Using custom ProcessorFactory: {}", processorFactory);
            getContext().getCamelContextExtension().addContextPlugin(ProcessorFactory.class, processorFactory);
        }
        Debugger debugger = getBeanForType(Debugger.class);
        if (debugger != null) {
            LOG.info("Using custom Debugger: {}", debugger);
            getContext().setDebugger(debugger);
        }
        setupUuidGenerator();
        NodeIdFactory nodeIdFactory = getBeanForType(NodeIdFactory.class);
        if (nodeIdFactory != null) {
            LOG.info("Using custom NodeIdFactory: {}", nodeIdFactory);
            getContext().getCamelContextExtension().addContextPlugin(NodeIdFactory.class, nodeIdFactory);
        }
        StreamCachingStrategy streamCachingStrategy = getBeanForType(StreamCachingStrategy.class);
        if (streamCachingStrategy != null) {
            LOG.info("Using custom StreamCachingStrategy: {}", streamCachingStrategy);
            getContext().setStreamCachingStrategy(streamCachingStrategy);
        }
        MessageHistoryFactory messageHistoryFactory = getBeanForType(MessageHistoryFactory.class);
        if (messageHistoryFactory != null) {
            LOG.info("Using custom MessageHistoryFactory: {}", messageHistoryFactory);
            getContext().setMessageHistoryFactory(messageHistoryFactory);
        }
        ReactiveExecutor reactiveExecutor = getBeanForType(ReactiveExecutor.class);
        if (reactiveExecutor != null) {
             
            getContext().getCamelContextExtension().setReactiveExecutor(reactiveExecutor);
        }
    }

    public Exchange add(CamelContext camelContext, String key, Exchange oldExchange, Exchange newExchange)
            throws OptimisticLockingException {
        if (!optimistic) {
            throw new UnsupportedOperationException();
        }
        LOG.trace("Adding an Exchange with ID {} for key {} in an optimistic manner.", newExchange.getExchangeId(), key);
        if (oldExchange == null) {
            DefaultExchangeHolder holder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            final DefaultExchangeHolder misbehaviorHolder = cache.putIfAbsent(key, holder);
            if (misbehaviorHolder != null) {
                Exchange misbehaviorEx = unmarshallExchange(camelContext, misbehaviorHolder);
                LOG.warn(
                        "Optimistic locking failed for exchange with key {}: IMap#putIfAbsend returned Exchange with ID {}, while it's expected no exchanges to be returned",
                        key, misbehaviorEx != null ? misbehaviorEx.getExchangeId() : "<null>");
                throw new OptimisticLockingException();
            }
        } else {
            DefaultExchangeHolder oldHolder = DefaultExchangeHolder.marshal(oldExchange, true, allowSerializedHeaders);
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            if (!cache.replace(key, oldHolder, newHolder)) {
                LOG.warn(
                        "Optimistic locking failed for exchange with key {}: IMap#replace returned no Exchanges, while it's expected to replace one",
                        key);
                throw new OptimisticLockingException();
            }
        }
        LOG.trace("Added an Exchange with ID {} for key {} in optimistic manner.", newExchange.getExchangeId(), key);
        return oldExchange;
    }

    public Expression createExpression(CamelContext camelContext, String expression) {
        Expression answer = null;
        if (block != null) {
            answer = block.createExpression(camelContext, expression);
        }
        if (answer == null) {
             
            answer = ExpressionBuilder.constantExpression("");
        }
        return answer;
    }

        public void enqueue(final ThrottlePermit permit, final Exchange exchange) {
            permit.setDelayMs(getTimePeriodMillis());
            delayQueue.put(permit);
            try {
                ScheduledFuture<?> next = asyncExecutor.schedule(this::clean, cleanPeriodMillis, TimeUnit.MILLISECONDS);
                ScheduledFuture<?> prev = cleanFuture.getAndSet(next);
                if (prev != null) {
                    prev.cancel(false);
                }
                 
                if (LOG.isTraceEnabled()) {
                    LOG.trace("Permit released, for exchangeId: {}", exchange.getExchangeId());
                }
            } catch (RejectedExecutionException e) {
                LOG.debug("Throttling queue cleaning rejected", e);
            }
        }

    public static String getBrokerURLFromConnectionFactory(BeanIntrospection bi, ConnectionFactory cf) {
         
        if (cf == null) {
            return null;
        }
        Map<String, Object> props = new HashMap<>();
        bi.getProperties(cf, props, null, false);
        Object url = props.get("brokerURL");
        if (url != null) {
            return url.toString();
        } else {
             
            ConnectionFactory ncf = (ConnectionFactory) props.get("connectionFactory");
            if (ncf != null) {
                return getBrokerURLFromConnectionFactory(bi, ncf);
            }
        }
        return artemisBrokerURL(cf);
    }

    public static ApplicationPkcs7MimeEnvelopedDataEntity parseApplicationPkcs7MimeEnvelopedDataEntityBody(
            AS2SessionInputBuffer inbuffer,
            InputStream is,
            String boundary,
            ContentType contentType,
            String contentTransferEncoding)
            throws ParseException {

        CharsetDecoder previousDecoder = inbuffer.getCharsetDecoder();

        try {
            byte[] encryptedContent = parseBodyPartBytes(inbuffer, is, boundary, contentType, contentTransferEncoding);
            return new ApplicationPkcs7MimeEnvelopedDataEntity(encryptedContent, contentTransferEncoding, false);
        } catch (Exception e) {
            ParseException parseException = new ParseException("failed to parse PKCS7 Mime entity");
            parseException.initCause(e);
            throw parseException;
        } finally {
            inbuffer.setCharsetDecoder(previousDecoder);
        }
    }

    protected void sendReply(
            Session session,
            String replyDestination, final Message message, final Exchange exchange,
            final org.apache.camel.Message out, final Exception cause) {
        if (replyDestination == null) {
            LOG.debug("Cannot send reply message as there is no replyDestination for: {}", out);
            return;
        }
        try {
            SessionCallback callback = createSessionCallback(replyDestination, message, exchange, out, cause,
                    endpoint.getJmsObjectFactory()::createMessageProducer);

            getTemplate().execute(session, callback);

        } catch (Exception e) {
            exchange.setException(new CamelExchangeException("Unable to send reply JMS message", exchange, e));
        }
    }

    public HttpServerInitializerFactory(NettyHttpConsumer nettyConsumer) {
        this.consumer = nettyConsumer;
        this.configuration = nettyConsumer.getConfiguration();
        try {
            this.sslContext = createSSLContext(consumer.getContext(), consumer.getConfiguration());
        } catch (Exception e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        }

        if (sslContext != null) {
            LOG.info("Created SslContext {}", sslContext);
        }
    }

    public static BoxAPIConnection createAppEnterpriseAuthenticatedConnection(BoxConfiguration configuration) {
         
        JWTEncryptionPreferences encryptionPref = new JWTEncryptionPreferences();
        encryptionPref.setPublicKeyID(configuration.getPublicKeyId());

        try {
            encryptionPref.setPrivateKey(new String(Files.readAllBytes(Paths.get(configuration.getPrivateKeyFile()))));
        } catch (Exception e) {
            throw new RuntimeCamelException("Box API connection failed: could not read privateKeyFile", e);
        }

        encryptionPref.setPrivateKeyPassword(configuration.getPrivateKeyPassword());
        encryptionPref.setEncryptionAlgorithm(configuration.getEncryptionAlgorithm());

        IAccessTokenCache accessTokenCache = configuration.getAccessTokenCache();
        if (accessTokenCache == null) {
            accessTokenCache = new InMemoryLRUAccessTokenCache(configuration.getMaxCacheEntries());
        }

        try {
            return BoxDeveloperEditionAPIConnection.getAppEnterpriseConnection(configuration.getEnterpriseId(),
                    configuration.getClientId(), configuration.getClientSecret(), encryptionPref, accessTokenCache);
        } catch (BoxAPIException e) {
            throw new RuntimeCamelException(
                    String.format("Box API connection failed: API returned the error code %d%n%n%s",
                            e.getResponseCode(), e.getResponse()),
                    e);
        }

    }

    public RestDefinition disabled(String disabled) {
        if (getVerbs().isEmpty()) {
            this.disabled = disabled;
        } else {
             
            VerbDefinition verb = getVerbs().get(getVerbs().size() - 1);
            verb.setDisabled(disabled);
        }

        return this;
    }

    public boolean hasNext() {
        if (closed) {
            return false;
        }

        boolean hasNext = currentSearchHits.hasNext();
        if (!hasNext) {
            updateCurrentSearchHits();

            hasNext = currentSearchHits.hasNext();
        }

        return hasNext;
    }

    public void setPrivateKeyName(String privateKeyName) {
        if (context != null && privateKeyName != null) {
            PrivateKey pk = context.getRegistry().lookupByNameAndType(privateKeyName, PrivateKey.class);
            if (pk != null) {
                setPrivateKey(pk);
            }
        }
        if (privateKeyName != null) {
            this.privateKeyName = privateKeyName;
        }
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        try {
            Object newVariable = expression.evaluate(exchange, Object.class);

            if (exchange.getException() != null) {
                 
                callback.done(true);
                return true;
            }

            String key = variableName.evaluate(exchange, String.class);
            ExchangeHelper.setVariable(exchange, key, newVariable);
        } catch (Exception e) {
            exchange.setException(e);
        }

        callback.done(true);
        return true;
    }

    protected HazelcastInstance getOrCreateHzClientInstance(CamelContext context, Map<String, Object> parameters)
            throws Exception {
        HazelcastInstance hzInstance = null;
        ClientConfig config = null;

         
        hzInstance = resolveAndRemoveReferenceParameter(parameters, HAZELCAST_INSTANCE_PARAM, HazelcastInstance.class);

         
        if (hzInstance == null && parameters.get(HAZELCAST_INSTANCE_NAME_PARAM) != null) {
            hzInstance = HazelcastClient.getHazelcastClientByName((String) parameters.get(HAZELCAST_INSTANCE_NAME_PARAM));
        }

         
         
        if (hzInstance == null) {
            config = resolveAndRemoveReferenceParameter(parameters, HAZELCAST_CONFIGU_PARAM, ClientConfig.class);
            if (config == null) {
                String configUri = getAndRemoveParameter(parameters, HAZELCAST_CONFIGU_URI_PARAM, String.class);
                if (configUri != null) {
                    configUri = getCamelContext().resolvePropertyPlaceholders(configUri);
                }
                if (configUri != null) {
                    InputStream is = ResourceHelper.resolveMandatoryResourceAsInputStream(context, configUri);
                    config = new XmlClientConfigBuilder(is).build();
                }
            }

            if (hazelcastInstance == null && config == null) {
                config = new XmlClientConfigBuilder().build();
                 
                config.getProperties().setProperty("hazelcast.version.check.enabled", "false");
                config.getProperties().setProperty("hazelcast.phone.home.enabled", "false");

                hzInstance = HazelcastClient.newHazelcastClient(config);
            } else if (config != null) {
                hzInstance = HazelcastClient.newHazelcastClient(config);
            }

            if (hzInstance != null) {
                if (this.customHazelcastInstances.add(hzInstance)) {
                    LOGGER.debug("Add managed HZ instance {}", hzInstance.getName());
                }
            }
        }

        return hzInstance == null ? hazelcastInstance : hzInstance;
    }

    public Integer doProcessWatchCall() throws Exception {
        List<Row> rows = new ArrayList<>();

        List<Long> pids = findPids(name);
        ProcessHandle.allProcesses()
                .filter(ph -> pids.contains(ph.pid()))
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                     
                    if (root != null) {
                        Row row = new Row();
                        JsonObject context = (JsonObject) root.get("context");
                        if (context == null) {
                            return;
                        }
                        row.name = context.getString("name");
                        if ("CamelJBang".equals(row.name)) {
                            row.name = ProcessHelper.extractName(root, ph);
                        }
                        row.pid = Long.toString(ph.pid());

                        JsonObject jo = (JsonObject) root.get("groovy");
                        if (jo != null) {
                            jo = (JsonObject) jo.get("compiler");
                        }
                        if (jo != null) {
                            row = row.copy();
                            row.compiledCounter = jo.getInteger("compiledCounter");
                            row.preloaddCounter = jo.getInteger("preloadedCounter");
                            row.classesSize = jo.getInteger("classesSize");
                            row.time = jo.getLong("compiledTime");
                            row.last = jo.getLong("lastCompilationTimestamp");
                            row.compiledClasses.clear();
                            JsonArray arr = jo.getCollection("classes");
                            for (int i = 0; arr != null && i < arr.size(); i++) {
                                row.compiledClasses.add(arr.getString(i));
                            }
                            rows.add(row);
                        }
                    }
                });

         
        rows.sort(this::sortRow);

        if (!rows.isEmpty()) {
            printer().println(AsciiTable.getTable(AsciiTable.NO_BORDERS, rows, Arrays.asList(
                    new Column().header("PID").headerAlign(HorizontalAlign.CENTER).with(r -> r.pid),
                    new Column().header("NAME").dataAlign(HorizontalAlign.LEFT).maxWidth(30, OverflowBehaviour.ELLIPSIS_RIGHT)
                            .with(r -> r.name),
                    new Column().header("PRELOAD").headerAlign(HorizontalAlign.CENTER).with(r -> "" + r.preloaddCounter),
                    new Column().header("COMPILE").headerAlign(HorizontalAlign.CENTER).with(r -> "" + r.compiledCounter),
                    new Column().header("TIME").headerAlign(HorizontalAlign.CENTER).with(this::getTime),
                    new Column().header("SINCE").headerAlign(HorizontalAlign.CENTER).with(this::getLast),
                    new Column().header("CLASSES").headerAlign(HorizontalAlign.LEFT).dataAlign(HorizontalAlign.LEFT)
                            .maxWidth(60, OverflowBehaviour.ELLIPSIS_LEFT).with(this::getClasses))));
        }

        return 0;
    }

    public static void initializeSantuario() {
         
        boolean wasSet = false;
        try {
             
            String lineBreakPropName = "org.apache.xml.security.ignoreLineBreaks";
            if (System.getProperty(lineBreakPropName) == null) {
                System.setProperty(lineBreakPropName, "true");
                wasSet = false;
            } else {
                wasSet = true;
            }
        } catch (Exception t) {
             
        }

        org.apache.xml.security.Init.init();

        if (!wasSet) {
            try {
                Field f = XMLUtils.class.getDeclaredField("ignoreLineBreaks");
                f.setAccessible(true);
                f.set(null, Boolean.TRUE);
            } catch (Exception t) {
                 
            }
        }
    }

    private int readTraceFiles(Map<Long, Pid> pids) throws Exception {
        int lines = 0;

        for (Pid pid : pids.values()) {
            if (pid.reader == null) {
                Path file = getTraceFile(pid.pid);
                if (Files.exists(file)) {
                    pid.reader = new LineNumberReader(Files.newBufferedReader(file));
                    if (tail == 0) {
                         
                        long size = Files.size(file);
                        pid.reader.skip(size);
                    }
                }
            }
            if (pid.reader != null) {
                String line;
                do {
                    try {
                        line = pid.reader.readLine();
                        if (line != null) {
                            lines++;
                             
                            if (pid.fifo == null || pid.fifo instanceof ArrayBlockingQueue) {
                                pid.fifo = new ArrayDeque<>();
                            }
                            pid.fifo.offer(line);
                        }
                    } catch (IOException e) {
                         
                        line = null;
                    }
                } while (line != null);
            }
        }

        return lines;
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.apache.solr.client.solrj.request.ContentStreamUpdateRequest.class, java.lang.Object.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.solr.converter.SolrRequestConverter.createContentStreamUpdateRequest(value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.solr.client.solrj.request.QueryRequest.class, java.lang.Object.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.solr.converter.SolrRequestConverter.createQueryRequest(value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.solr.client.solrj.request.SolrPing.class, java.lang.Object.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.solr.converter.SolrRequestConverter.createSolrPing(value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.solr.client.solrj.request.UpdateRequest.class, java.lang.Object.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.solr.converter.SolrRequestConverter.createUpdateRequest(value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    public static ApplicationEntity parseEDIEntityBody(
            AS2SessionInputBuffer inbuffer,
            InputStream is,
            String boundary,
            ContentType ediMessageContentType,
            String contentTransferEncoding,
            String filename)
            throws ParseException {
        CharsetDecoder previousDecoder = inbuffer.getCharsetDecoder();

        try {
            Charset charset = ediMessageContentType.getCharset();
            if (charset == null) {
                charset = StandardCharsets.US_ASCII;
            }
            CharsetDecoder charsetDecoder = charset.newDecoder();

            inbuffer.setCharsetDecoder(charsetDecoder);

            byte[] ediMessageBodyPartContentBytes
                    = parseBodyPartBytes(inbuffer, is, boundary, ediMessageContentType, contentTransferEncoding);

            return EntityUtils.createEDIEntity(ediMessageBodyPartContentBytes,
                    ediMessageContentType, contentTransferEncoding, false, filename);
        } catch (Exception e) {
            ParseException parseException = new ParseException("failed to parse EDI entity");
            parseException.initCause(e);
            throw parseException;
        } finally {
            inbuffer.setCharsetDecoder(previousDecoder);
        }
    }

    private void createUser(IamClient iamClient, Exchange exchange) throws InvalidPayloadException {
        executeOperation(
                exchange,
                CreateUserRequest.class,
                iamClient::createUser,
                () -> {
                    String userName = getRequiredHeader(exchange, IAM2Constants.USERNAME, String.class, MISSING_USER_NAME);
                    return iamClient.createUser(CreateUserRequest.builder().userName(userName).build());
                },
                "Create user",
                (CreateUserResponse response, Message message) -> {
                    if (response.user() != null) {
                        message.setHeader(IAM2Constants.USER_ARN, response.user().arn());
                        message.setHeader(IAM2Constants.USER_ID, response.user().userId());
                    }
                });
    }

    protected void doStop() throws Exception {
        super.doStop();
        localLog.info("Stopping Google PubSub Lite consumer for {}/{}", endpoint.getProjectId(), endpoint.getDestinationName());

        synchronized (subscribers) {
            if (!subscribers.isEmpty()) {
                localLog.info("Stopping subscribers for {}/{}", endpoint.getProjectId(), endpoint.getDestinationName());
                subscribers.forEach(Subscriber::stopAsync);
            }
        }

        if (executor != null) {
            if (getEndpoint() != null && getEndpoint().getCamelContext() != null) {
                getEndpoint().getCamelContext().getExecutorServiceManager().shutdownGraceful(executor);
            } else {
                executor.shutdownNow();
            }
        }
        executor = null;
    }

    public Object unmarshal(final Exchange exchange, final InputStream stream) throws Exception {
        if (usingIterator) {
            TarIterator tarIterator = new TarIterator(exchange, stream);
            tarIterator.setAllowEmptyDirectory(allowEmptyDirectory);
            return tarIterator;
        } else {
            BufferedInputStream bis = new BufferedInputStream(stream);
            TarArchiveInputStream tis = (TarArchiveInputStream) new ArchiveStreamFactory()
                    .createArchiveInputStream(ArchiveStreamFactory.TAR, bis);
            OutputStreamBuilder osb = OutputStreamBuilder.withExchange(exchange);

            try {
                TarArchiveEntry entry = tis.getNextEntry();
                if (entry != null) {
                    exchange.getMessage().setHeader(FILE_NAME, entry.getName());
                    IOHelper.copy(tis, osb, IOHelper.DEFAULT_BUFFER_SIZE, false, maxDecompressedSize);
                } else {
                    throw new IllegalStateException("Unable to untar the file, it may be corrupted.");
                }

                entry = tis.getNextEntry();
                if (entry != null) {
                    throw new IllegalStateException("Tar file has more than 1 entry.");
                }

                return osb.build();

            } finally {
                IOHelper.close(osb, tis, bis);
            }
        }
    }

    public V take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            for (;;) {
                Task t = queue.peek();
                if (t != null && (!ordered || index.compareAndSet(t.id, t.id + 1))) {
                    queue.poll();
                    return t.result;
                }
                available.await();
            }
        } finally {
            lock.unlock();
        }
    }

    protected int poll() throws Exception {
        final String fileSystemName = getEndpoint().getConfiguration().getFileSystemName();
        final String fileName = getEndpoint().getConfiguration().getFileName();
        final DataLakeFileSystemClient dataLakeFileSystemClient
                = getEndpoint().getDataLakeServiceClient().getFileSystemClient(fileSystemName);
        int result;

        try {
            Queue<Exchange> exchanges;
            if (ObjectHelper.isNotEmpty(fileName)) {
                final Exchange exchange = createExchangeFromFile(fileName, dataLakeFileSystemClient);
                exchanges = new LinkedList<>();
                exchanges.add(exchange);
            } else {
                exchanges = createBatchExchangesFromPath(dataLakeFileSystemClient);
            }
            result = processBatch(CastUtils.cast(exchanges));
        } catch (DataLakeStorageException e) {
            if (NOT_FOUND == e.getStatusCode()) {
                result = 0;
            } else {
                throw e;
            }
        }
        return result;
    }

    public void beforeTracingEvent(Span span, Exchange exchange, Endpoint endpoint) {
        super.beforeTracingEvent(span, exchange, endpoint);
        span.setTag(TagConstants.DB_SYSTEM, CASSANDRA_DB_TYPE);
        URI uri = URI.create(endpoint.getEndpointUri());
        if (uri.getPath() != null && !uri.getPath().isEmpty()) {
             
            span.setTag(TagConstants.DB_NAME, uri.getPath().substring(1));
        }

        String cql = exchange.getIn().getHeader(CAMEL_CQL_QUERY, String.class);
        if (cql != null) {
            span.setTag(TagConstants.DB_STATEMENT, cql);
        } else {
            Map<String, String> queryParameters = toQueryParameters(endpoint.getEndpointUri());
            if (queryParameters.containsKey("cql")) {
                span.setTag(TagConstants.DB_STATEMENT, queryParameters.get("cql"));
            }
        }
    }

    protected void unInitReplyManager() {
        try {
            if (replyManager != null) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("Stopping JmsReplyManager: {} from processing replies from: {}", replyManager,
                            endpoint.getReplyTo() != null ? endpoint.getReplyTo() : "temporary queue");
                }
                ServiceHelper.stopService(replyManager);
            }
        } catch (Exception e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        } finally {
            started.set(false);
        }
    }

private int jjMoveStringLiteralDfa1_0(long active0){
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(0, active0);
      return 1;
   }
   switch(curChar)
   {
      case 78:
         return jjMoveStringLiteralDfa2_0(active0, 0x8L);
      case 85:
         return jjMoveStringLiteralDfa2_0(active0, 0x4L);
      default :
         break;
   }
   return jjStartNfa_0(0, active0);
}

    private Collection<Consumer<byte[]>> createMultipleConsumers(final PulsarEndpoint pulsarEndpoint) {
        final Collection<Consumer<byte[]>> consumers = new LinkedList<>();
        final PulsarConfiguration configuration = pulsarEndpoint.getPulsarConfiguration();

        for (int i = 0; i < configuration.getNumberOfConsumers(); i++) {
            final String consumerName = configuration.getConsumerNamePrefix() + i;
            try {
                ConsumerBuilder<byte[]> builder
                        = CommonCreationStrategyImpl.getBuilder(consumerName, pulsarEndpoint, pulsarConsumer);

                consumers.add(builder.subscriptionType(SubscriptionType.Key_Shared).subscribe());
            } catch (PulsarClientException exception) {
                LOGGER.error("A PulsarClientException occurred when creating Consumer {}, {}", consumerName,
                        exception.getMessage(), exception);
            }
        }
        return consumers;
    }

    private void setupCustomServices() {
        ModelJAXBContextFactory modelJAXBContextFactory = getBeanForType(ModelJAXBContextFactory.class);
        if (modelJAXBContextFactory != null) {
            LOG.info("Using custom ModelJAXBContextFactory: {}", modelJAXBContextFactory);
            getContext().getCamelContextExtension().addContextPlugin(ModelJAXBContextFactory.class, modelJAXBContextFactory);
        }
        ClassResolver classResolver = getBeanForType(ClassResolver.class);
        if (classResolver != null) {
            LOG.info("Using custom ClassResolver: {}", classResolver);
            getContext().setClassResolver(classResolver);
        }
        FactoryFinderResolver factoryFinderResolver = getBeanForType(FactoryFinderResolver.class);
        if (factoryFinderResolver != null) {
            LOG.info("Using custom FactoryFinderResolver: {}", factoryFinderResolver);
            getContext().getCamelContextExtension().addContextPlugin(FactoryFinderResolver.class, factoryFinderResolver);
        }
        ExecutorServiceManager executorServiceStrategy = getBeanForType(ExecutorServiceManager.class);
        if (executorServiceStrategy != null) {
            LOG.info("Using custom ExecutorServiceStrategy: {}", executorServiceStrategy);
            getContext().setExecutorServiceManager(executorServiceStrategy);
        }
        ThreadPoolFactory threadPoolFactory = getBeanForType(ThreadPoolFactory.class);
        if (threadPoolFactory != null) {
            LOG.info("Using custom ThreadPoolFactory: {}", threadPoolFactory);
            getContext().getExecutorServiceManager().setThreadPoolFactory(threadPoolFactory);
        }
        ProcessorFactory processorFactory = getBeanForType(ProcessorFactory.class);
        if (processorFactory != null) {
            LOG.info("Using custom ProcessorFactory: {}", processorFactory);
            getContext().getCamelContextExtension().addContextPlugin(ProcessorFactory.class, processorFactory);
        }
        Debugger debugger = getBeanForType(Debugger.class);
        if (debugger != null) {
            LOG.info("Using custom Debugger: {}", debugger);
            getContext().setDebugger(debugger);
        }
        setupUuidGenerator();
        NodeIdFactory nodeIdFactory = getBeanForType(NodeIdFactory.class);
        if (nodeIdFactory != null) {
            LOG.info("Using custom NodeIdFactory: {}", nodeIdFactory);
            getContext().getCamelContextExtension().addContextPlugin(NodeIdFactory.class, nodeIdFactory);
        }
        StreamCachingStrategy streamCachingStrategy = getBeanForType(StreamCachingStrategy.class);
        if (streamCachingStrategy != null) {
            LOG.info("Using custom StreamCachingStrategy: {}", streamCachingStrategy);
            getContext().setStreamCachingStrategy(streamCachingStrategy);
        }
        MessageHistoryFactory messageHistoryFactory = getBeanForType(MessageHistoryFactory.class);
        if (messageHistoryFactory != null) {
            LOG.info("Using custom MessageHistoryFactory: {}", messageHistoryFactory);
            getContext().setMessageHistoryFactory(messageHistoryFactory);
        }
        ReactiveExecutor reactiveExecutor = getBeanForType(ReactiveExecutor.class);
        if (reactiveExecutor != null) {
             
            getContext().getCamelContextExtension().setReactiveExecutor(reactiveExecutor);
        }
    }

    protected void printSource(List<Row> rows) {
        for (Row row : rows) {
            printer().println();
            if (!raw) {
                printer().printf("Source: %s%n", row.location);
                printer().println("--------------------------------------------------------------------------------");
            }
            for (int i = 0; i < row.code.size(); i++) {
                Code code = row.code.get(i);
                String c = StringHelper.limitLength(Jsoner.unescape(code.code), 90, " (clipped)");
                String pad = StringHelper.padString(code.level);
                if (raw) {
                    printer().printf("%s%s%n", pad, c);
                } else {
                    if (code.line != -1) {
                        printer().printf("%4d: %s%s%n", code.line, pad, c);
                    } else {
                        printer().printf("      %s%s%n", pad, c);
                    }
                }
            }
            printer().println();
        }
    }

    protected String doCallText(Map<String, Object> options) {
        StringBuilder sb = new StringBuilder();

        if (propertiesFunction != null) {
            sb.append("Kubernetes Config maps Cluster:");
            sb.append(String.format("\n    Master Url: %s", propertiesFunction.getClient().getMasterUrl()));
            sb.append("\n    Login: OAuth Token");
            KubernetesVaultConfiguration kubernetes
                    = getCamelContext().getVaultConfiguration().getKubernetesVaultConfiguration();
            if (kubernetes != null) {
                sb.append(String.format("\n    Refresh Enabled: %s", kubernetes.isRefreshEnabled()));
            }
            if (cmRefreshTask != null) {
                Instant start = cmRefreshTask.getStartingTime();
                String s = start != null ? TimeUtils.printSince(start.toEpochMilli()) : "none";
                sb.append(String.format("\n    Running Since: %s", s));
            }
            List<String> sorted = new ArrayList<>();
            if (kubernetes != null) {
                sb.append("\n\nSecrets in use:");

                sorted = new ArrayList<>(List.of(kubernetes.getSecrets().split(",")));
                Collections.sort(sorted);
            }

            for (String sec : sorted) {
                sb.append(String.format("\n    %s", sec));
            }
        }

        return sb.toString();
    }

    public void setupJacksonXml(
            CamelContext camelContext, RestConfiguration config,
            String type, Class<?> typeClass, String outType, Class<?> outTypeClass,
            DataFormat xml, DataFormat outXml)
            throws Exception {
         
        PropertyConfigurer configurer = PluginHelper.getConfigurerResolver(camelContext)
                .resolvePropertyConfigurer("jacksonXml-dataformat-configurer", camelContext);
        if (configurer == null) {
            throw new IllegalStateException("Cannot find configurer for dataformat: jacksonXml");
        }

         
         
         

        PropertyBindingSupport.Builder builder = PropertyBindingSupport.build()
                .withCamelContext(camelContext)
                .withConfigurer(configurer)
                .withTarget(xml);

        final String typeName = getTypeName(type, typeClass);
        if (typeName != null) {
            builder.withProperty("unmarshalTypeName", typeName);
        }

        setAdditionalConfiguration(config, "xml.in.", builder);
        builder.bind();

         
         
         

        PropertyBindingSupport.Builder outBuilder = PropertyBindingSupport.build()
                .withCamelContext(camelContext)
                .withConfigurer(configurer)
                .withTarget(outXml);

        final String outTypeName = getOutTypeName(outType, outTypeClass, typeName);

        if (outTypeName != null) {
            outBuilder.withProperty("unmarshalTypeName", outTypeName);
        }

        setAdditionalConfiguration(config, "xml.out.", outBuilder);
        outBuilder.bind();
    }

    protected void doStop() throws Exception {
        if (contextServicePlugins != null) {
            for (ContextServicePlugin plugin : contextServicePlugins) {
                try {
                    plugin.unload(camelContext);
                } catch (Exception e) {
                    LOG.warn(
                            "Unloading of plugin {} failed, however the exception will be ignored so shutdown can continue. Reason: {}",
                            plugin.getClass().getName(), e.getMessage(), e);
                }
            }
        }
    }

    public PollingConsumer createPollingConsumer() throws Exception {
        if (maxMessagesPerPoll > 1) {
            throw new IllegalArgumentException(
                    "The option maxMessagesPerPoll is not supported for polling consumer (such as when using poll or pollEnrich EIP)");
        }

        if (LOG.isDebugEnabled()) {
            LOG.debug("Creating GenericFilePollingConsumer with queueSize: {} blockWhenFull: {} blockTimeout: {}",
                    getPollingConsumerQueueSize(), isPollingConsumerBlockWhenFull(),
                    getPollingConsumerBlockTimeout());
        }
        GenericFilePollingConsumer result = new GenericFilePollingConsumer(this);
         
         
        result.setBlockWhenFull(isPollingConsumerBlockWhenFull());
        result.setBlockTimeout(getPollingConsumerBlockTimeout());

        return result;
    }

    public Object remove(Object key) {
        lock.lock();
        try {
            locations.remove(key);
            defaultValues.remove(key);
            return super.remove(key);
        } finally {
            lock.unlock();
        }
    }

    private void tagDroplet(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
        if (ObjectHelper.isEmpty(exchange.getIn().getHeader(DigitalOceanHeaders.NAME))) {
            throw new IllegalArgumentException(DigitalOceanHeaders.NAME + " must be specified");
        }

        ArrayList<Resource> resources = new ArrayList<>(1);
        resources.add(new Resource(dropletId.toString(), ResourceType.DROPLET));
        Response response = getEndpoint().getDigitalOceanClient().tagResources(dropletId.toString(), resources);
        LOG.trace("Tag Droplet {} : [{}] ", dropletId, response);
        exchange.getMessage().setBody(response);
    }

        public String getValue() {

            StringBuilder builder = new StringBuilder();
            for (int i = 0; i < elements.length; i++) {
                Element element = elements[i];
                if (i > 0) {
                    builder.append("; ").append(element);
                } else {
                    builder.append(element);
                }
            }

            return builder.toString();
        }

    public static String extractSourceLocationId(String location) {
        int cnt = StringHelper.countChar(location, ':');
        if (cnt >= 1) {
            int pos = location.lastIndexOf(':');
            return location.substring(pos + 1);
        } else {
            return null;
        }
    }

    protected void processStrategyCommit(
            GenericFileProcessStrategy<T> processStrategy, Exchange exchange, GenericFile<T> file) {
        if (Boolean.TRUE.equals(endpoint.isIdempotent())) {
             
             
            String key = absoluteFileName;
            if (endpoint.getIdempotentKey() != null) {
                Exchange dummy = GenericFileHelper.createDummy(endpoint, exchange, () -> file);
                key = endpoint.getIdempotentKey().evaluate(dummy, String.class);
            }
             
            if (key != null) {
                 
                if (endpoint.isIdempotentEager()) {
                    endpoint.getIdempotentRepository().confirm(key);
                } else {
                    endpoint.getIdempotentRepository().add(key);
                }
            }
        }

        handleDoneFile(exchange);

        try {
            LOG.trace("Commit file strategy: {} for file: {}", processStrategy, file);
            processStrategy.commit(operations, endpoint, exchange, file);
        } catch (Exception e) {
            handleException("Error during commit", exchange, e);
        }
    }

    public Map<String, String> getServiceMetadata() {
        Map<String, String> map = new HashMap<>();
        if (configuration.getClientId() != null) {
            map.put("clientId", configuration.getClientId());
        }
        if (configuration.getUserName() != null) {
            map.put("username", configuration.getUserName());
        }
        return map.isEmpty() ? null : map;
    }

    public Message next() {
        if (parent == null) {
            parent = getNextElement();
        }
        Message answer = parent;
        parent = null;

        if (first && answer == null) {
            throw new IllegalStateException("Unable to untar the file, it may be corrupted.");
        }

        first = false;
        checkNullAnswer(answer);

        return answer;
    }